PyPI / pandas / 3.0.6

pandas 3.0.6

Source
https://github.com/pandas-dev/pandas
Artifact scanned
pandas-3.0.6.tar.gz (sdist · 4.5 MB · SHA-256 66b07ef7315a…)
Compared with
pandas-3.0.5.tar.gz (0 signals introduced since)
Files
1493 scanned, 104 skipped (binary, oversized, or unrecognised)
Signals
0 critical · 0 warn · 50 info
Scan time
28.2 s
LLM review
Reviewed by claude-haiku-5-5 (Anthropic): 34 of 34 warn and critical signals; 34 demoted to info.
Disclude version
4.3.0
Scanned (UTC)
2026-10-23 01:01

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-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.93 Dynamic __import__ of optional pandas dependencies inside a try/except in the package init.
    Reasoning

    This is the standard optional-dependency import loop in pandas' package init, importing a dependency name from a constant list and re-raising a clear ImportError. Dynamic import of a known list of module names is legitimate.

  5. 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.95 Frame introspection to find the caller frame for warning assertions in testing helpers.
    Reasoning

    Walking up the call stack via inspect.currentframe to locate the caller for warning stacklevel is a common pandas testing utility; no network, decoding or execution involved.

  6. 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.94 sys._getframe used to scan caller local variables in a core helper.
    Reasoning

    sys._getframe(2) used to search caller locals for an object, a known pandas pattern for resolving names in scope; benign introspection.

  7. 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.95 eval on a parsed pandas expression node inside the query/eval computation engine.
    Reasoning

    This is pandas' query-expression engine evaluating parsed expression trees, which is the library's documented eval feature on internally parsed, validated expressions. Expected in a data library, though eval is inherently risky.

  8. 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.94 sys._getframe used to capture variable scope for pandas eval/query.
    Reasoning

    Scope resolution in pandas eval captures caller frames to access local and global variables for query expressions. Standard for this module.

  9. 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.94 inspect.stack call capturing variable scope for pandas query evaluation.
    Reasoning

    inspect.stack used to capture calling scope for pandas query evaluation, with a comment explaining its purpose. Benign.

  10. 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 local keyword arguments by name via vars() to forward to a styler method.
    Reasoning

    vars() lookup of keyword argument names from the local scope to forward to the Styler method; this is a fixed list of names and a plain getattr call. Not malicious.

  11. 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-literal SAS file magic signature constant in the SAS reader.
    Reasoning

    The bytes literal is the SAS file magic number constant used to identify SAS7BDAT files. A binary signature in a parser constant is expected, not a hidden payload.

  12. 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.93 eval of a test-constructed expression string to verify pandas eval output.
    Reasoning

    Test code evaluating a locally constructed query string to compare against pandas eval results. Test-only use with controlled inputs.

  13. 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.93 eval of a test expression string in a pandas eval test.
    Reasoning

    Test helper evaluating a hardcoded test expression to compare with the engine result. Test-only.

  14. 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.93 eval of a test expression string in a pandas eval test.
    Reasoning

    Same pattern as the sibling test: eval of a test-defined expression for comparison. Test-only.

  15. 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.93 eval of a parametrized function name to construct a random state in a sample test.
    Reasoning

    Test evaluating a parametrized function name string (e.g. numpy RandomState constructor) to build a random state. Test-only with fixed parameters.

  16. 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.93 eval of a parametrized function name in a sample test.
    Reasoning

    Same parametrized eval pattern in a sample test; fixed test inputs.

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

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

                    DataFrame(
                        5 * [[123, "Γειά σου", "Κόσμε"]],  # noqa: RUF001
                        columns=["X", "Y", "Z"],
                    ),
  19. 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.94 eval of an Index repr string to verify round-trip formatting.
    Reasoning

    Round-trip check that eval(repr(idx)) reconstructs an Index in a repr test. Test-only on a locally created object.

  20. 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.94 eval of a CategoricalIndex repr to verify round-trip formatting.
    Reasoning

    Round-trip repr check for a CategoricalIndex in a test; local object, test-only.

  21. 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.94 eval of a MultiIndex repr to verify round-trip formatting.
    Reasoning

    Round-trip repr check for a MultiIndex in a test; local object, test-only.

  22. 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.93 Test helper evaluating the repr of an Index to verify round-tripping.
    Reasoning

    The eval is applied to repr(index) inside a test to check that an Index round-trips through its repr. The input is the object's own repr, not untrusted data, and the file is a pandas test module.

  23. 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.93 Test evaluating a RangeIndex repr string to check round-tripping.
    Reasoning

    eval is applied to a repr string produced within a pandas RangeIndex test to confirm the repr reconstructs an equal index. This is a standard round-trip assertion in test code.

  24. 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.93 Test evaluating a RangeIndex repr string to check round-tripping.
    Reasoning

    Same pattern as the other range test: eval of a locally generated repr string, followed by an index equality assertion. No external input reaches eval.

  25. 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.93 Test using eval on a fixture index repr to verify round-tripping.
    Reasoning

    eval(repr(index)) on a fixture index in a pandas test, asserting the repr is valid and reconstructs the index. Input is self-generated.

  26. 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.93 Test evaluating an index repr to confirm round-trip equality.
    Reasoning

    eval(repr(idx)) on a simple_index fixture in a pandas base-index test. This is a repr round-trip check on locally constructed data.

  27. 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)
  28. 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)
  29. 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.
  30. 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.90 Test installing a no-op profiler hook around a parser call to assert no Python function calls occur.
    Reasoning

    sys.setprofile with a no-op lambda is set around a parser read call, then cleared. This is a common pandas test technique to assert that the C parser makes no Python-level function calls during parsing. It does not inspect or exfiltrate frames.

  31. 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.90 Clears the no-op profiler hook used in a parser test.
    Reasoning

    The matching sys.setprofile(None) clears the no-op hook set on the previous line. Part of the same benign test-harness pattern.

  32. 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(
  33. 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(
  34. 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
  35. 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"],
  36. 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"],
  37. 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)
  38. 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.93 Test evaluating a Timestamp repr to verify round-tripping.
    Reasoning

    eval(repr(result)) on a Timestamp in a constructor test, checking that the repr is a valid expression that reconstructs the value. Self-generated input.

  39. 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.93 Test evaluating a Timestamp repr to verify round-tripping.
    Reasoning

    Same repr round-trip assertion on a Timestamp in a pandas constructor test.

  40. 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.93 Test evaluating a Timestamp repr to verify round-tripping.
    Reasoning

    Same repr round-trip assertion on a Timestamp in a pandas constructor test.

  41. 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.93 Test evaluating a Timestamp repr to verify round-tripping.
    Reasoning

    Same repr round-trip assertion on a Timestamp in a pandas constructor test.

  42. 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.93 Test evaluating a Timestamp repr to verify round-tripping.
    Reasoning

    eval of repr(date_only) in a Timestamp formatting test, checking round-trip equality. Self-generated, no external input.

  43. 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.93 Test evaluating a timezone-aware Timestamp repr to verify round-tripping.
    Reasoning

    eval of repr(date_tz) in a timezone-aware Timestamp repr test. Standard round-trip check on locally generated data.

  44. 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.93 Test evaluating a UTC-offset Timestamp repr to verify round-tripping.
    Reasoning

    eval of a repr string of a Timestamp with UTC offset in a formatting test. Round-trip assertion only.

  45. 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.93 Test looping over timezones and evaluating each repr to verify round-tripping.
    Reasoning

    Loop over zones evaluating repr(z) and asserting equality with z in a pre-1900 repr test. Self-generated input in test code.

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

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

                (
                    Series(["123", "Γειά σου", "Κόσμε"], name="Ελληνικά"),  # noqa: RUF001
                    "cp737",
                ),
  48. 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
    dismissed LLM, confidence 0.95 A long random-looking string literal used as hashing test input in pandas.
    Reasoning

    The snippet is a long random-looking string literal inside a pandas hashing test, used as input data to check hash stability. Test fixtures commonly contain random strings like this. Raw-pass base64 heuristics have a high false-positive rate, and nothing here decodes or executes the blob.

  49. 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
    dismissed LLM, confidence 0.95 Another random string literal used as hashing test data in pandas.
    Reasoning

    Same file and pattern as the adjacent finding: a long random string literal serving as test data for hash functions. It is not decoded or executed, so it is a legitimate test fixture.

  50. 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.93 pandas uses inspect.currentframe() to walk the call stack when adjusting exception messages.
    Reasoning

    Using inspect.currentframe() to find the caller's frame is a standard pandas technique for rewriting exception messages with the calling function's context. It is a legitimate use of call-stack introspection with no network, process, or dynamic execution involved.

Reproduce This Scan

Run disclude locally to verify. These commands scan the published file; the "new in this release" marks come from comparing it with the previous release's file, which they don't repeat. 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.3.0
curl -fsSL -o pandas-3.0.6.tar.gz https://files.pythonhosted.org/packages/e2/17/d7b106e05bfa642e8694451e7d3d759c6a241c5386a5d962e4f66c047e06/pandas-3.0.6.tar.gz
printf '%s  %s\n' 66b07ef7315a31bfe1089cd3d71a7de781c9dca986762d0b4fe7c0ef17465d10 pandas-3.0.6.tar.gz | shasum -a 256 -c -
mkdir pkg && tar -xzf pandas-3.0.6.tar.gz -C pkg --strip-components 1
disclude scan --untrusted --severity info pkg