PyPI / pandas / 3.0.6

pandas 3.0.6

Source
https://github.com/pandas-dev/pandas
Tag scanned
v3.0.6
Compared with
v3.0.5 (0 signals introduced since)
Files
1866 scanned, 605 skipped (binary, oversized, or unrecognised)
Signals
0 critical · 0 warn · 60 info
Scan time
26.4 s
LLM review
Reviewed by claude-haiku-5-5 (Anthropic): 41 of 41 warn and critical signals; 41 demoted to info.
Disclude version
4.0.0
Scanned (UTC)
2026-10-14 18:16

Signals

Ordered by severity, then signals introduced in this release. Hidden characters are shown as ⟨U+…⟩.

  1. info long-line README.md:13:1

    line length 503 characters (raw pass, confidence 0.50)

    | Package | [![PyPI Latest Release]https://img.shields.io/pypi/v/pandas.svg]https://pypi.org/project/pandas/ [![PyPI Downloads]https://img.shields.io/pypi/dm/pandas.svg?label=PyPI%20downloads]https://pypi.org/project/pandas/ [![Conda Latest Release]https://anaconda.org/conda-forge/pandas/badges/version.svg](h
  2. info long-line README.md:14:1

    line length 750 characters (raw pass, confidence 0.50)

    | Meta | [![Powered by NumFOCUS]https://img.shields.io/badge/powered%20by-NumFOCUS-orange.svg?style=flat&colorA=E1523D&colorB=007D8A]https://numfocus.org [![DOI]https://zenodo.org/badge/DOI/10.5281/zenodo.3509134.svg]https://doi.org/10.5281/zenodo.3509134 [![License - BSD 3-Clause](https://img.shields.io/pypi/l
  3. info long-line README.md:178:1

    line length 538 characters (raw pass, confidence 0.50)

    If you are simply looking to start working with the pandas codebase, navigate to the [GitHub "issues" tab]https://github.com/pandas-dev/pandas/issues and start looking through interesting issues. There are a number of issues listed under [Docs](https://github.com/pandas-dev/pandas/issues?q=is%3Aissue%20state%3Aopen%2
  4. info critical → info by review dynamic-execution ci/run_tests.sh:18:1

    `sh -c` called with a dynamic string — equivalent to eval (ast pass, confidence 0.88)

    echo "$PYTEST_CMD"
    sh -c "$PYTEST_CMD"
    likely benign LLM, confidence 0.90 CI script that runs a test command taken from the PYTEST_CMD environment variable via sh -c.
    Reasoning

    sh -c on a variable is equivalent to eval, but PYTEST_CMD is a CI test-command variable set by the project's own pipeline; this is a common, legitimate pattern for running configurable test commands, though it is a minor injection surface if the variable is attacker-controlled.

  5. info warn → info by review whitespace-anomaly doc/source/user_guide/advanced.rst:182:2

    invisible whitespace U+00A0 in indentation (raw pass, confidence 0.80)

    
     ⟨U+00A0⟩ df.columns.levels  # original MultiIndex
    
       df[["foo","qux"]].columns.levels  # sliced
    likely benign LLM, confidence 0.93 Documentation file containing non-breaking spaces in indentation.
    Reasoning

    A non-breaking space in RST indentation is a typical artifact of copy-pasting from rendered docs; it is harmless in documentation prose and code examples.

  6. info warn → info by review whitespace-anomaly doc/source/user_guide/advanced.rst:319:2

    invisible whitespace U+00A0 in indentation (raw pass, confidence 0.80)

       for the **columns**. There are some ambiguous cases where the passed indexer could be misinterpreted
     ⟨U+00A0⟩ as indexing *both* axes, rather than into say the ``MultiIndex`` for the rows.
    
       You should do this:
    likely benign LLM, confidence 0.93 Non-breaking space in RST prose indentation of the advanced indexing guide.
    Reasoning

    Same copy-paste whitespace artifact in pandas user guide prose; no executable impact.

  7. info warn → info by review whitespace-anomaly doc/source/user_guide/advanced.rst:327:2

    [embedded python] invisible whitespace U+00A0 in indentation (raw pass, confidence 0.80)

    
     ⟨U+00A0⟩ You should **not** do this:
    ⟨U+00A0⟩
       .. code-block:: python
    likely benign LLM, confidence 0.93 Non-breaking space in RST around an embedded python code-block.
    Reasoning

    Non-breaking space before a code-block directive in documentation; cosmetic copy artifact with no code effect.

  8. info warn → info by review whitespace-anomaly doc/source/user_guide/advanced.rst:328:1

    invisible whitespace U+00A0 in indentation (raw pass, confidence 0.80)

     ⟨U+00A0⟩ You should **not** do this:
    ⟨U+00A0⟩
       .. code-block:: python
    likely benign LLM, confidence 0.93 Non-breaking space in RST documentation near a code example.
    Reasoning

    Same cosmetic whitespace artifact in docs; the embedded example is documentation text only.

  9. info identifier-low-length doc/source/whatsnew/v0.16.0.rst:388:1

    [embedded python] 21 of 47 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  10. line length 636 characters (raw pass, confidence 0.50)

    - :class:`.DataError`, :class:`.SpecificationError`, ``SettingWithCopyError``, ``SettingWithCopyWarning``, :class:`.NumExprClobberingError`, :class:`.UndefinedVariableError`, :class:`.IndexingError`, :class:`.PyperclipException`, :class:`.PyperclipWindowsException`, :class:`.CSSWarning`, :class:`.PossibleDataLossError`
  11. line length 615 characters (raw pass, confidence 0.50)

    - Deprecated the ``axis`` keyword in :meth:`.DataFrameGroupBy.idxmax`, :meth:`.DataFrameGroupBy.idxmin`, :meth:`.DataFrameGroupBy.fillna`, :meth:`.DataFrameGroupBy.take`, :meth:`.DataFrameGroupBy.skew`, :meth:`.DataFrameGroupBy.rank`, :meth:`.DataFrameGroupBy.cumprod`, :meth:`.DataFrameGroupBy.cumsum`, :meth:`.DataFram
  12. info critical → info by review dynamic-import pandas/__init__.py:11:9

    `__import__` called on a non-literal expression (ast pass, confidence 0.70)

        try:
            __import__(_dependency)
        except ImportError as _e:  # pragma: no cover
            raise ImportError(
    likely benign LLM, confidence 0.90 Dynamic __import__ of pandas' hard dependency names inside a version-check loop.
    Reasoning

    pandas' __init__ imports its required dependencies dynamically by name from a fixed list in a version-check loop, re-raising ImportError with a helpful message. This is a standard, legitimate dependency check.

  13. info warn → info by review frame-introspection pandas/_testing/_warnings.py:252:13

    `inspect.currentframe` — call-stack frame introspection (ast pass, confidence 0.70)

        # https://stackoverflow.com/questions/17407119/python-inspect-stack-is-slow
        frame = inspect.currentframe()
        for _ in range(4):
            frame = frame.f_back  # type: ignore[union-attr]
    likely benign LLM, confidence 0.92 Test helper walking the call stack via inspect.currentframe to find the warning's caller.
    Reasoning

    Walking up the stack a fixed number of frames to locate the caller for warning assertions is a standard testing utility technique, with a comment explaining it.

  14. info warn → info by review frame-introspection pandas/core/common.py:681:13

    `sys._getframe` — call-stack frame introspection (ast pass, confidence 0.70)

        """
        frame = sys._getframe(2)
        for v in frame.f_locals.values():
            if v is obj:
    likely benign LLM, confidence 0.92 Helper reading caller's local variables via sys._getframe for scope resolution.
    Reasoning

    sys._getframe(2) to access caller locals in a pandas helper is a known, benign introspection pattern used for resolving variable scope in query/eval-like utilities.

  15. info warn → info by review dynamic-execution pandas/core/computation/ops.py:425:23

    `eval` called on a non-literal expression (ast pass, confidence 0.70)

    
                    res = eval(self, local_dict=env, engine=engine, parser=parser)
    
            name = env.add_tmp(res)
    likely benign LLM, confidence 0.93 Expression evaluation within pandas' computation engine using eval on parsed operator nodes.
    Reasoning

    pandas' query/eval engine intentionally evaluates parsed expression nodes via eval; this is the core documented design of DataFrame.eval, not injected malicious code.

  16. info warn → info by review frame-introspection pandas/core/computation/scope.py:165:17

    `sys._getframe` — call-stack frame introspection (ast pass, confidence 0.70)

    
            frame = sys._getframe(self.level)
    
            try:
    likely benign LLM, confidence 0.92 Scope resolver using sys._getframe to capture the calling frame's variables for eval.
    Reasoning

    Fetching a frame at a configured level to capture variable scope is the standard mechanism for pandas eval scope resolution.

  17. info warn → info by review frame-introspection pandas/core/computation/scope.py:308:17

    `inspect.stack` — call-stack frame introspection (ast pass, confidence 0.70)

            # makes sure that we can capture variable scope
            stack = inspect.stack()
    
            try:
    likely benign LLM, confidence 0.92 Scope builder calling inspect.stack to capture variables for query evaluation.
    Reasoning

    inspect.stack is used by pandas' eval scope builder to capture caller variables; a known, legitimate, if slow, technique.

  18. info warn → info by review dynamic-attribute pandas/core/generic.py:3715:18

    reach-by-name through `vars` (ast pass, confidence 0.60)

            ]:
                kw = vars()[kw_name]
                if isinstance(kw, dict):
                    getattr(styler, kw_name)(**kw)
    likely benign LLM, confidence 0.90 Reads named local keyword arguments via vars() to forward to a Styler method.
    Reasoning

    vars()[kw_name] reads local variables by name for a fixed list of styler keyword arguments; it is a local, non-malicious lookup with no external input reaching execution.

  19. info warn → info by review payload-bytes-literal pandas/io/sas/sas_constants.py:6:5

    concatenated bytes literal contains 32 `\xNN` escapes (100% of content) — binary payload shape (ast pass, confidence 0.85)

    magic: Final = (
        b"\x00\x00\x00\x00\x00\x00\x00\x00"
        b"\x00\x00\x00\x00\xc2\xea\x81\x60"
        b"\xb3\x14\x11\xcf\xbd\x92\x08\x00"
    likely benign LLM, confidence 0.90 Byte-string constant defining the SAS7BDAT file magic header.
    Reasoning

    The bytes literal is the SAS file magic number and header constants, a well-known file-format signature. It is a legitimate constant table, not a dropper payload.

  20. info warn → info by review dynamic-execution pandas/tests/computation/test_eval.py:794:36

    `eval` called on a non-literal expression (ast pass, confidence 0.70)

            assert res.values.dtype == dtype
            tm.assert_frame_equal(res, eval(s), check_exact=False)
    likely benign LLM, confidence 0.90 Test code evaluating a generated expression string to validate query results.
    Reasoning

    In a test, eval is applied to a locally constructed expression string to compare against pandas' result; it is test code with no external input.

  21. info warn → info by review dynamic-execution pandas/tests/computation/test_eval.py:1147:15

    `eval` called on a non-literal expression (ast pass, confidence 0.70)

            res = self.eval(ex)
            exp = eval(ex)
            assert res == exp
    likely benign LLM, confidence 0.90 Test helper uses eval on a test-generated expression string to compute the expected result.
    Reasoning

    Test code evaluating expressions generated by the test suite itself to compare against pandas eval results; eval of a locally constructed test string is a standard pattern in pandas tests and not attacker-controlled.

  22. info warn → info by review dynamic-execution pandas/tests/computation/test_eval.py:1163:15

    `eval` called on a non-literal expression (ast pass, confidence 0.70)

            res = self.eval(ex)
            exp = eval(ex)
            assert res == exp
    likely benign LLM, confidence 0.90 Test computes expected value by eval-ing a generated test expression.
    Reasoning

    Same pattern as the sibling finding: eval of a locally generated test expression for result comparison in a pandas test module.

  23. info warn → info by review dynamic-execution pandas/tests/frame/methods/test_sample.py:198:47

    `eval` called on a non-literal expression (ast pass, confidence 0.70)

            obj = tm.get_obj(obj, frame_or_series)
            result = obj.sample(n=3, random_state=eval(func_str)(arg))
            expected = obj.sample(n=3, random_state=com.random_state(eval(func_str)(arg)))
            tm.assert_equal(result, expected)
    likely benign LLM, confidence 0.90 Test resolves a random-state constructor by name via eval for sampling comparison.
    Reasoning

    eval(func_str)(arg) resolves a numpy/random-state constructor name from a parametrized test list; a test-only round-trip with no external input.

  24. info warn → info by review dynamic-execution pandas/tests/frame/methods/test_sample.py:199:66

    `eval` called on a non-literal expression (ast pass, confidence 0.70)

            result = obj.sample(n=3, random_state=eval(func_str)(arg))
            expected = obj.sample(n=3, random_state=com.random_state(eval(func_str)(arg)))
            tm.assert_equal(result, expected)
    likely benign LLM, confidence 0.90 Test evaluates a parametrized constructor string to build a random state for comparison.
    Reasoning

    Same parametrized eval of a constructor name in a test; no untrusted input reaches it.

  25. identifier `Κόσμε` contains homoglyph candidates: Κ (039A)→K (in string/comment) (raw pass, confidence 0.35)

                    DataFrame(
                        5 * [[123, "Γειά σου", "Κόσμε"]],  # noqa: RUF001
                        columns=["X", "Y", "Z"],
                    ),
  26. identifier `Κόσμε` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)

                    DataFrame(
                        5 * [[123, "Γειά σου", "Κόσμε"]],  # noqa: RUF001
                        columns=["X", "Y", "Z"],
                    ),
  27. info warn → info by review dynamic-execution pandas/tests/indexes/base_class/test_formats.py:15:15

    `eval` called on a non-literal expression (ast pass, confidence 0.70)

            idx = Index(["a", "b"])
            res = eval(repr(idx))
            tm.assert_index_equal(res, idx)
    likely benign LLM, confidence 0.92 Test checks that repr of an Index round-trips through eval.
    Reasoning

    Round-trip test eval(repr(idx)) verifying that the repr is evaluable; a deliberate pattern in pandas tests operating on known objects.

  28. info warn → info by review dynamic-execution pandas/tests/indexes/categorical/test_category.py:207:31

    `eval` called on a non-literal expression (ast pass, confidence 0.70)

            str(ci)
            tm.assert_index_equal(eval(repr(ci)), ci, exact=True)
    
            # formatting
    likely benign LLM, confidence 0.92 Test verifies repr round-trip of a CategoricalIndex via eval.
    Reasoning

    eval(repr(ci)) round-trip assertion on a locally constructed CategoricalIndex in a pandas test; benign.

  29. info warn → info by review dynamic-execution pandas/tests/indexes/multi/test_formats.py:22:9

    `eval` called on a non-literal expression (ast pass, confidence 0.70)

        with pytest.raises(TypeError, match=msg):
            eval(repr(mi))
    likely benign LLM, confidence 0.92 Test evaluates repr of a MultiIndex, expecting a TypeError in the surrounding block.
    Reasoning

    Repr round-trip inside a pytest.raises block for MultiIndex in a test module; benign test code.

  30. info warn → info by review dynamic-execution pandas/tests/indexes/numeric/test_numeric.py:37:31

    `eval` called on a non-literal expression (ast pass, confidence 0.70)

            index = Index(index_data, dtype=dtype)
            tm.assert_index_equal(eval(repr(index)), index, exact=True)
    
        def check_coerce(self, a, b, is_float_index=True):
    likely benign LLM, confidence 0.92 Test checks that eval of an index repr reproduces the index.
    Reasoning

    Repr round-trip equality check on a locally built index in a pandas numeric index test.

  31. info warn → info by review dynamic-execution pandas/tests/indexes/ranges/test_range.py:64:18

    `eval` called on a non-literal expression (ast pass, confidence 0.70)

    
            result = eval(result)
            tm.assert_index_equal(result, i, exact=True)
    likely benign LLM, confidence 0.92 Test evaluates a RangeIndex repr string to verify it reconstructs the index.
    Reasoning

    eval of a repr string for RangeIndex in a test to verify the repr; local test data only.

  32. info warn → info by review dynamic-execution pandas/tests/indexes/ranges/test_range.py:72:18

    `eval` called on a non-literal expression (ast pass, confidence 0.70)

    
            result = eval(result)
            tm.assert_index_equal(result, i, exact=True)
    likely benign LLM, confidence 0.92 Test evaluates a RangeIndex repr string to verify reconstruction.
    Reasoning

    Same repr round-trip test pattern for RangeIndex; benign.

  33. info warn → info by review dynamic-execution pandas/tests/indexes/ranges/test_range.py:392:31

    `eval` called on a non-literal expression (ast pass, confidence 0.70)

            index = simple_index
            tm.assert_index_equal(eval(repr(index)), index)
    
        def test_slice_keep_name(self):
    likely benign LLM, confidence 0.92 Test checks eval(repr(index)) equals the index.
    Reasoning

    Repr round-trip on a fixture index in a pandas test; no external input.

  34. info warn → info by review dynamic-execution pandas/tests/indexes/test_old_base.py:236:31

    `eval` called on a non-literal expression (ast pass, confidence 0.70)

            idx = simple_index
            tm.assert_index_equal(eval(repr(idx)), idx)
    
        def test_repr_max_seq_item_setting(self, simple_index):
    likely benign LLM, confidence 0.92 Test verifies repr of a simple index round-trips via eval.
    Reasoning

    Repr round-trip on a fixture index inside a pandas test module; benign.

  35. identifier `АБВГДабвгд가` mixes scripts: Cyrillic + Hangul (in string/comment) (raw pass, confidence 0.40)

        with open(temp_file, "w", encoding="utf-8") as f:
            f.write('{"£©µÀÆÖÞßéöÿ":["АБВГДабвгд가"]}')
    
        result = read_json(temp_file, engine=engine)
  36. identifier `АБВГДабвгд가` mixes scripts: Cyrillic + Hangul (in string/comment) (raw pass, confidence 0.40)

        result = read_json(temp_file, engine=engine)
        expected = DataFrame({"£©µÀÆÖÞßéöÿ": ["АБВГДабвгд가"]})
        tm.assert_frame_equal(result, expected)
  37. identifier `sй` mixes scripts: Latin + Cyrillic (in string/comment) (raw pass, confidence 0.40)

    
    @pytest.mark.parametrize("filename", ["sé-es-vé.csv", "ru-sй.csv", "中文文件名.csv"])
    def test_filename_with_special_chars(all_parsers, filename, tmp_path):
        # see gh-15086.
  38. info warn → info by review frame-introspection pandas/tests/io/parser/common/test_common_basic.py:687:5

    `sys.setprofile` — call-stack frame introspection (ast pass, confidence 0.70)

    
        sys.setprofile(lambda *a, **k: None)
        result = getattr(parser, read_func)(StringIO(data))
        sys.setprofile(None)
    likely benign LLM, confidence 0.85 Test installs a no-op sys profile hook around a CSV read call and then clears it.
    Reasoning

    Temporarily setting a no-op profile hook around a parser call in a test to exercise profiling code paths; sys.setprofile is used legitimately for profiling tests and the lambda does nothing harmful.

  39. info warn → info by review frame-introspection pandas/tests/io/parser/common/test_common_basic.py:689:5

    `sys.setprofile` — call-stack frame introspection (ast pass, confidence 0.70)

        result = getattr(parser, read_func)(StringIO(data))
        sys.setprofile(None)
    
        expected = DataFrame({"a b": ["0 1"]})
    likely benign LLM, confidence 0.93 A pandas test resets the profiling hook via sys.setprofile(None) after a read call.
    Reasoning

    sys.setprofile(None) is used to clear a profiler hook installed around a parser call in a test, a common pattern for checking parser behavior; clearing a profile hook is not malicious and the surrounding code is a normal pandas test.

  40. info unicode-mixed-script pandas/tests/io/test_clipboard.py:57:43

    identifier `Ωœ` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)

        elif data_type == "utf8":
            return DataFrame({"a": ["µasd", "Ωœ∑`"], "b": ["øπ∆˚¬", "œ∑`®"]})
        elif data_type == "utf16":
            return DataFrame(
  41. info unicode-mixed-script pandas/tests/io/test_clipboard.py:57:62

    identifier `øπ` mixes scripts: Latin + Greek (in string/comment) (raw pass, confidence 0.40)

        elif data_type == "utf8":
            return DataFrame({"a": ["µasd", "Ωœ∑`"], "b": ["øπ∆˚¬", "œ∑`®"]})
        elif data_type == "utf16":
            return DataFrame(
  42. info unicode-mixed-script pandas/tests/io/test_clipboard.py:338:57

    identifier `Ωœ` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)

    
        @pytest.mark.parametrize("data", ["\U0001f44d...", "Ωœ∑`...", "abcd..."])
        def test_raw_roundtrip(self, data):
            # PR #25040 wide unicode wasn't copied correctly on PY3 on windows
  43. info unicode-mixed-script pandas/tests/io/test_stata.py:1896:15

    identifier `ᴘᴀᴎᴅᴀS` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)

                ["ƤĀńĐąŜ", "Ö", "a", "ƤĀńĐąŜ", "a"],
                ["ᴘᴀᴎᴅᴀS", "Ü", "n", "ᴘᴀᴎᴅᴀS", "n"],
                ["      ", "      ", "d", "      ", "d"],
                [" ", "", "a", " ", "a"],
  44. info unicode-mixed-script pandas/tests/io/test_stata.py:1896:46

    identifier `ᴘᴀᴎᴅᴀS` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)

                ["ƤĀńĐąŜ", "Ö", "a", "ƤĀńĐąŜ", "a"],
                ["ᴘᴀᴎᴅᴀS", "Ü", "n", "ᴘᴀᴎᴅᴀS", "n"],
                ["      ", "      ", "d", "      ", "d"],
                [" ", "", "a", " ", "a"],
  45. info unicode-mixed-script pandas/tests/io/test_stata.py:2020:23

    identifier `ᴅaᵀa` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)

            }
            data_label = "ᴅaᵀa-label"
            value_labels = {"β": {1: "label", 2: "æøå", 3: "ŋot valid latin-1"}}
            data["β"] = data["β"].astype(np.int32)
  46. info warn → info by review dynamic-execution pandas/tests/scalar/timestamp/test_constructors.py:690:26

    `eval` called on a non-literal expression (ast pass, confidence 0.70)

            assert repr(result) == expected
            assert result == eval(repr(result))
    
            # This should be 2013-11-01 05:00 in UTC
    likely benign LLM, confidence 0.95 Test checks that repr of a Timestamp round-trips through eval.
    Reasoning

    eval(repr(result)) is a round-trip repr test in pandas' Timestamp test suite; the input is the object's own repr, not attacker-controlled data.

  47. info warn → info by review dynamic-execution pandas/tests/scalar/timestamp/test_constructors.py:698:26

    `eval` called on a non-literal expression (ast pass, confidence 0.70)

            assert repr(result) == expected
            assert result == eval(repr(result))
    
            # GH11708
    likely benign LLM, confidence 0.95 Test evaluates repr of a Timestamp to verify round-tripping.
    Reasoning

    Same round-trip repr test pattern using eval on the object's own repr in a test file; benign.

  48. info warn → info by review dynamic-execution pandas/tests/scalar/timestamp/test_constructors.py:707:26

    `eval` called on a non-literal expression (ast pass, confidence 0.70)

            assert repr(result) == expected
            assert result == eval(repr(result))
    
            # This should be 2015-11-18 10:00 in UTC
    likely benign LLM, confidence 0.95 Test evaluates repr of a Timestamp to verify round-tripping.
    Reasoning

    Same benign round-trip repr test using eval on self-generated repr output.

  49. info warn → info by review dynamic-execution pandas/tests/scalar/timestamp/test_constructors.py:715:26

    `eval` called on a non-literal expression (ast pass, confidence 0.70)

            assert repr(result) == expected
            assert result == eval(repr(result))
    
        def test_constructor_invalid(self):
    likely benign LLM, confidence 0.95 Test evaluates repr of a Timestamp to verify round-tripping.
    Reasoning

    Same benign round-trip repr test using eval on self-generated repr output.

  50. info warn → info by review dynamic-execution pandas/tests/scalar/timestamp/test_formats.py:115:29

    `eval` called on a non-literal expression (ast pass, confidence 0.70)

            assert freq_repr not in repr(date_only)
            assert date_only == eval(repr(date_only))
    
            date_tz = Timestamp(date, tz=tz)
    likely benign LLM, confidence 0.95 Test evaluates repr of a Timestamp to check round-trip equality.
    Reasoning

    eval of repr of a Timestamp in a formatting test; the input is locally generated and the pattern is standard in pandas tests.

  51. info warn → info by review dynamic-execution pandas/tests/scalar/timestamp/test_formats.py:121:27

    `eval` called on a non-literal expression (ast pass, confidence 0.70)

            assert freq_repr not in repr(date_tz)
            assert date_tz == eval(repr(date_tz))
    
        def test_repr_utcoffset(self):
    likely benign LLM, confidence 0.95 Test evaluates repr of a timezone-aware Timestamp.
    Reasoning

    Same benign repr round-trip eval in a timezone repr test.

  52. info warn → info by review dynamic-execution pandas/tests/scalar/timestamp/test_formats.py:131:40

    `eval` called on a non-literal expression (ast pass, confidence 0.70)

            expr = repr(date_with_utc_offset)
            assert date_with_utc_offset == eval(expr)
    
        def test_timestamp_repr_pre1900(self):
    likely benign LLM, confidence 0.95 Test evaluates repr of a Timestamp with a UTC offset.
    Reasoning

    eval of the repr of a locally constructed Timestamp with UTC offset in a test; benign.

  53. info warn → info by review dynamic-execution pandas/tests/scalar/timestamp/test_formats.py:168:20

    `eval` called on a non-literal expression (ast pass, confidence 0.70)

            for z in zs:
                assert eval(repr(z)) == z
    
        def test_repr_matches_pydatetime_no_tz(self):
    likely benign LLM, confidence 0.95 Test evaluates repr of pre-1900 Timestamps in a loop.
    Reasoning

    eval(repr(z)) over a list of pre-1900 timestamps in a test; inputs are test-controlled and benign.

  54. identifier `Κόσμε` contains homoglyph candidates: Κ (039A)→K (in string/comment) (raw pass, confidence 0.35)

                (
                    Series(["123", "Γειά σου", "Κόσμε"], name="Ελληνικά"),  # noqa: RUF001
                    "cp737",
                ),
  55. identifier `Κόσμε` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)

                (
                    Series(["123", "Γειά σου", "Κόσμε"], name="Ελληνικά"),  # noqa: RUF001
                    "cp737",
                ),
  56. info warn → info by review encoding-base64 pandas/tests/util/test_hashing.py:359:17

    base64-like blob (505 bytes, compression ratio 0.80) (raw pass, confidence 0.60)

            "Ingrid-9Z9fKIZmkO7i7Cn51Li34pJm44fgX6DYGBNj3VPlOH50m7HnBlPxfIwFMrcNJNMP6PSgLmwWnInciMWrCSAlLEvt7JkJl4IxiMrVbXSa8ZQoVaq5xoQPjltuJEfwdNlO6jo8qRRHvD8sBEBMQASrRa6TsdaPTPCBo3nwIBpE7YzzmyH0vMBhjQZLx1aCT7faSEx7PgFxQhHdKFWROcysamgy9iVj8DO2Fmwg1NNl93rIAqC3mdqfrCxrzfvIY8aJdzin2cHVzy3QUJxZgHvtUtOLxoqnUHsYbNTeq0xcLXpTZEZC
    likely benign LLM, confidence 0.90 A long random-looking string literal in a pandas hashing test fixture.
    Reasoning

    A long string literal in a hashing test is test fixture data (expected hash inputs or values), not an executable payload; the raw base64-like heuristic fires on random-looking test strings and such raw matches have high false-positive rates.

  57. info warn → info by review encoding-base64 pandas/tests/util/test_hashing.py:360:14

    base64-like blob (508 bytes, compression ratio 0.80) (raw pass, confidence 0.60)

            "Tim-b9MddTxOWW2AT1Py6vtVbZwGAmYCjbp89p8mxsiFoVX4FyDOF3wFiAkyQTUgwg9sVqVYOZo09Dh1AzhFHbgij52ylF0SEwgzjzHH8TGY8Lypart4p4onnDoDvVMBa0kdthVGKl6K0BDVGzyOXPXKpmnMF1H6rJzqHJ0HywfwS4XYpVwlAkoeNsiicHkJUFdUAhG229INzvIAiJuAHeJDUoyO4DCBqtoZ5TDend6TK7Y914yHlfH3g1WZu5LksKv68VQHJriWFYusW5e6ZZ6dKaMjTwEGuRgdT66iU5nqWTHRH8WSzpX
    likely benign LLM, confidence 0.90 A long random-looking string literal in a pandas hashing test fixture.
    Reasoning

    Same pattern: a random-looking string fixture in a hashing test, flagged by the raw pass heuristic; no decoding or execution is shown.

  58. info warn → info by review frame-introspection pandas/util/_exceptions.py:49:31

    `inspect.currentframe` — call-stack frame introspection (ast pass, confidence 0.70)

        # https://stackoverflow.com/questions/17407119/python-inspect-stack-is-slow
        frame: FrameType | None = inspect.currentframe()
        try:
            n = 0
    likely benign LLM, confidence 0.90 Pandas utility uses inspect.currentframe to walk the stack for warning attribution.
    Reasoning

    inspect.currentframe is used in pandas to locate the caller's stack frame for emitting warnings with the correct stacklevel, a well-known legitimate idiom.

  59. info warn → info by review dynamic-attribute scripts/validate_unwanted_patterns.py:478:22

    reach-by-name through `globals.get` (ast pass, confidence 0.60)

            main(
                function=globals().get(args.validation_type),
                source_path=args.paths,
                output_format=args.format,
    likely benign LLM, confidence 0.90 Pandas dev script dispatches a validation function by name looked up in globals() from a CLI argument.
    Reasoning

    globals().get with args.validation_type is a dispatch table lookup by name for a validation function in a pandas developer script. The input comes from CLI args choosing among validators; it is a legitimate dynamic dispatch pattern, not obfuscation. Minor risk only if validation_type were attacker-controlled, which is not the case for a local dev script.

  60. info warn → info by review unicode-zero-width web/pandas/community/blog/asv-pandas-grant.md:34:60

    U+200B ZERO WIDTH SPACE in source (raw pass, confidence 0.75)

    
    It all happened through Marc Garcia; he had put out a call ⟨U+200B⟩through a post
    on social media to mentor ladies from diverse backgrounds. Dorothy got to
    be part of the pandas mentorship group. At the same time, Lucy was
    likely benign LLM, confidence 0.95 A stray zero-width space inside a sentence of a pandas community blog post.
    Reasoning

    A single U+200B zero-width space in prose of a blog post about a pandas mentorship grant. This is a typical copy-paste artifact from word processors or web editors and carries no executable or hidden payload in a markdown article.

Reproduce This Scan

Run disclude locally to verify. Add --format sarif for SARIF output. Add --llm (with an API key in the environment) to include the LLM review.

cargo install disclude --version 4.0.0
git clone https://github.com/pandas-dev/pandas pandas && cd pandas
git checkout v3.0.6
disclude scan --severity info --diff v3.0.5 .