sqlalchemy 2.0.55

Source: https://github.com/sqlalchemy/sqlalchemy
Tag scanned: rel_2_0_55
Compared with: rel_2_0_54 (0 signals introduced since)
Files: 911 scanned, 27 skipped (binary, oversized, or unrecognised)
Signals: 0 critical · 0 warn · 45 info
Scan time: 42.1 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-17 00:41

Signals

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

info ~~critical~~ → info by review dynamic-import examples/performance/__init__.py:335:21

`__import__` called on a non-literal expression (ast pass, confidence 0.90)
```
                try:
                    __import__(__name__ + "." + potential_name)
                except ImportError:
                    pass
```
likely benign LLM, confidence 0.85 Example profiler dynamically imports sibling modules by name.
Reasoning
Dynamic __import__ of a module name built from the package name and a discovered profiler name. This is a plugin-style loader inside a benchmark example, not a dropper. The name comes from the local package layout, not from untrusted input.
info ~~critical~~ → info by review dynamic-import examples/performance/__init__.py:394:13

`__import__` called on a non-literal expression (ast pass, confidence 0.90)
```
        if cls.name is None:
            __import__(__name__ + "." + args.name)

        Profiler(args).run()
```
likely benign LLM, confidence 0.85 Example runner imports a profile module chosen by CLI argument.
Reasoning
Imports the profiler module named by a command-line argument within the same package. This is a standard dynamic-dispatch pattern for a benchmark runner, with no network, decoding, or shell involvement.
info ~~critical~~ → info by review dynamic-import lib/sqlalchemy/dialects/__init__.py:48:22

`__import__` called on a non-literal expression (ast pass, confidence 0.70)
```
        else:
            module = __import__("sqlalchemy.dialects.%s" % (dialect,)).dialects
            module = getattr(module, dialect)
    except ImportError:
```
likely benign LLM, confidence 0.92 Loads a SQLAlchemy database dialect module by name.
Reasoning
Standard SQLAlchemy dialect loader that imports sqlalchemy.dialects.<name> and falls back on ImportError. The dialect name is a configured database backend name, and the module path is fixed to the package namespace.
info ~~critical~~ → info by review dynamic-import lib/sqlalchemy/dialects/mysql/mariadb.py:54:19

`__import__` called on a non-literal expression (ast pass, confidence 0.70)
```
def loader(driver: str) -> type[MariaDBDialect]:
    dialect_mod = __import__(
        "sqlalchemy.dialects.mysql.%s" % driver
    ).dialects.mysql
```
likely benign LLM, confidence 0.92 Loads the MariaDB driver dialect module for a given driver name.
Reasoning
Driver-specific dialect loader that imports a submodule under sqlalchemy.dialects.mysql. This is the usual plugin mechanism and matches the library's design.
info ~~critical~~ → info by review dynamic-import lib/sqlalchemy/dialects/mysql/mariadbconnector.py:227:32

`__import__` called on a non-literal expression (ast pass, confidence 0.90)
```
            try:
                CLIENT_FLAGS = __import__(
                    self.dbapi.__name__ + ".constants.CLIENT"
                ).constants.CLIENT
```
likely benign LLM, confidence 0.93 Reads CLIENT flag constants from the MariaDB connector's dbapi package.
Reasoning
Imports the dbapi's own constants submodule to read CLIENT flags, guarded by try/except. The module name derives from the already-loaded dbapi, so this is ordinary driver introspection.
info ~~critical~~ → info by review dynamic-import lib/sqlalchemy/dialects/mysql/mysqldb.py:257:32

`__import__` called on a non-literal expression (ast pass, confidence 0.90)
```
            try:
                CLIENT_FLAGS = __import__(
                    self.dbapi.__name__ + ".constants.CLIENT"
                ).constants.CLIENT
```
likely benign LLM, confidence 0.93 Reads CLIENT flag constants from the MySQLdb dbapi package.
Reasoning
Same pattern as the MariaDB connector: imports dbapi.__name__ + '.constants.CLIENT' to get flag values. This is benign driver introspection.
info ~~critical~~ → info by review dynamic-import lib/sqlalchemy/engine/default.py:511:13

`__import__` called on a non-literal expression (ast pass, confidence 0.90)
```
        try:
            __import__(package + ".provision")
        except ImportError:
            pass
```
likely benign LLM, confidence 0.90 Optionally imports a package's provision module for testing support.
Reasoning
Imports the package's own provision submodule for the test tooling, and suppresses ImportError when it is absent. This is a plugin hook with no external input.
info ~~warn~~ → info by review dynamic-attribute lib/sqlalchemy/event/base.py:335:9

reach-by-name through `globals` (ast pass, confidence 0.60)
```
        # establish pickle capability by adding it to this module
        globals()[klass.__name__] = klass
```
likely benign LLM, confidence 0.90 Registers a dynamically created event class in module globals for pickling.
Reasoning
Registers a class in module globals so that pickle can resolve it by name. This is a known, documented technique for making dynamically created classes picklable, not evasion.
info ~~warn~~ → info by review dynamic-execution lib/sqlalchemy/orm/clsregistry.py:533:17

`eval` called on a non-literal expression (ast pass, confidence 0.70)
```
        try:
            x = eval(self.arg, globals(), self._dict)

            if isinstance(x, _GetColumns):
```
likely benign LLM, confidence 0.85 Evaluates developer-written relationship expression strings for the ORM class registry.
Reasoning
eval evaluates relationship primaryjoin/declarative string expressions written by the developer, against a controlled namespace. It is a documented SQLAlchemy feature, and the input is developer-authored code rather than untrusted data.
info ~~warn~~ → info by review dynamic-execution lib/sqlalchemy/orm/instrumentation.py:743:5

`exec` called on a non-literal expression (ast pass, confidence 0.70)
```
    env["__name__"] = __name__
    exec(func_text, env)
    __init__ = env["__init__"]
    __init__.__doc__ = original_init.__doc__
```
likely benign LLM, confidence 0.85 Generates a constructor from template text via exec to keep the signature.
Reasoning
exec runs generated function source text for __init__ with a controlled env, to preserve the original signature. This is code generation from the library's own templates, a common and legitimate approach.
info ~~warn~~ → info by review dynamic-attribute lib/sqlalchemy/sql/annotation.py:559:5

reach-by-name through `globals` (ast pass, confidence 0.60)
```
    )
    globals()["Annotated%s" % cls.__name__] = anno_cls

    if "_traverse_internals" in cls.__dict__:
```
likely benign LLM, confidence 0.90 Registers a generated annotated subclass in module globals.
Reasoning
Registers a generated Annotated<ClassName> class in globals() so it can be found by name and pickled. This is a standard metaprogramming pattern in the library.
info ~~warn~~ → info by review dynamic-attribute lib/sqlalchemy/sql/coercions.py:1397:20

reach-by-name through `globals` (ast pass, confidence 0.60)
```
        if name in globals():
            impl = globals()[name](cls)
            _impl_lookup[cls] = impl
```
likely benign LLM, confidence 0.90 Looks up a coercion implementation class from module globals.
Reasoning
Looks up a module-level implementation class by name from a fixed set of module names. This is a local registry lookup and nothing about it is hidden or attacker-driven.
info ~~warn~~ → info by review dynamic-execution lib/sqlalchemy/sql/lambdas.py:1263:9

`exec` called on a non-literal expression (ast pass, confidence 0.70)
```
        vars_ = {"o%d" % i: cell_values[i] for i in argrange}
        exec(code, vars_, vars_)
        closure = vars_["make_cells"]()
```
likely benign LLM, confidence 0.85 Executes generated helper code to rebuild closure cells.
Reasoning
exec runs generated code that builds cell objects for closure reconstruction, using internal variables. This is a known technique in the library for making closures from captured values, not a payload.
info ~~critical~~ → info by review dynamic-import lib/sqlalchemy/testing/engines.py:236:17

`__import__` called on a non-literal expression (ast pass, confidence 0.70)
```
            mod = getattr(
                __import__("sqlalchemy.dialects.%s" % name).dialects, name
            )
        yield mod.dialect()
```
likely benign LLM, confidence 0.92 Imports a dialect module for test engine setup.
Reasoning
Test-engine helper that imports a dialect module by name from a fixed set of test dialect names. It is part of the test harness and has no external input.
info ~~warn~~ → info by review frame-introspection lib/sqlalchemy/testing/fixtures/mypy.py:131:27

`inspect.stack` — call-stack frame introspection (ast pass, confidence 0.70)
```
        else:
            caller_path = inspect.stack()[1].filename
            path = os.path.join(os.path.dirname(caller_path), dirname)
        files = list(Path(path).glob("**/*.py"))
```
likely benign LLM, confidence 0.92 Uses call-stack inspection to resolve a test directory path.
Reasoning
Uses inspect.stack to locate the caller's directory for resolving test file paths. This is a routine test-fixture technique with no network or execution aspect.
info ~~critical~~ → info by review dynamic-import lib/sqlalchemy/testing/plugin/plugin_base.py:487:11

`__import__` called on a non-literal expression (ast pass, confidence 0.70)
```
    # late
    mod = __import__(modname)
    for component in modname.split(".")[1:]:
        mod = getattr(mod, component)
```
likely benign LLM, confidence 0.90 Imports a dotted module path for the pytest plugin loader.
Reasoning
Standard pytest plugin helper that imports a module by dotted name and walks its attributes. The module name is the test plugin's own configuration, and this is ordinary test tooling.
info ~~warn~~ → info by review dynamic-execution lib/sqlalchemy/testing/plugin/pytestplugin.py:646:9

`exec` called on a non-literal expression (ast pass, confidence 0.70)
```
        # in format_argpsec_plus()
        exec(code, env)
        return env[fn_name]
```
likely benign LLM, confidence 0.90 exec of generated Python source to build a function with a specific signature in the pytest plugin.
Reasoning
The exec runs generated function source built by SQLAlchemy's own format_argpsec_plus helper to create a function with a given signature. This is a standard code-generation pattern in a legitimate library, not obfuscation.
info ~~warn~~ → info by review frame-introspection lib/sqlalchemy/testing/schema.py:192:18

`sys._getframe` — call-stack frame introspection (ast pass, confidence 0.70)
```
    try:
        module = sys._getframe(1).f_globals.get("__name__", "__main__")
    except (AttributeError, ValueError):
        pass
```
likely benign LLM, confidence 0.90 Reads the calling frame's module name to set a module attribute on a test schema object.
Reasoning
sys._getframe(1) reads the caller's module name to set a default __module__ attribute, wrapped in a try/except. This is ordinary introspection for module attribution.

info unicode-mixed-script lib/sqlalchemy/testing/suite/test_reflection.py:2601:49

identifier `é試蛇ẟΩ` mixes scripts: Latin + Han + Greek (in string/comment) (raw pass, confidence 0.40)

            metadata,
            Column("unicode", Integer, comment="é試蛇ẟΩ"),
            Column("emoji", Integer, comment="☁⟨U+FE0F⟩✨"),
            comment="試蛇ẟΩ✨",

info unicode-mixed-script lib/sqlalchemy/testing/suite/test_reflection.py:2603:22

identifier `試蛇ẟΩ` mixes scripts: Han + Latin + Greek (in string/comment) (raw pass, confidence 0.40)
```
            Column("emoji", Integer, comment="☁⟨U+FE0F⟩✨"),
            comment="試蛇ẟΩ✨",
        )
```

info unicode-mixed-script lib/sqlalchemy/testing/suite/test_reflection.py:2610:27

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

        tc = insp.get_table_comment("unicode_comments")
        eq_(tc, {"text": "試蛇ẟΩ✨"})

        cols = insp.get_columns("unicode_comments")

info unicode-mixed-script lib/sqlalchemy/testing/suite/test_reflection.py:2614:28

identifier `é試蛇ẟΩ` mixes scripts: Latin + Han + Greek (in string/comment) (raw pass, confidence 0.40)

        value = {c["name"]: c["comment"] for c in cols}
        exp = {"unicode": "é試蛇ẟΩ", "emoji": "☁⟨U+FE0F⟩✨"}
        eq_(value, exp)

info ~~warn~~ → info by review dynamic-execution lib/sqlalchemy/util/langhelpers.py:321:5

`exec` called on a non-literal expression (ast pass, confidence 0.70)
```
) -> Callable[..., Any]:
    exec(code, env)
    return env[fn_name]  # type: ignore[no-any-return]
```
likely benign LLM, confidence 0.90 exec of generated wrapper source in langhelpers to create a callable with matching signature.
Reasoning
This is the same generated-function pattern as the other exec sites in langhelpers: source built from known function metadata, executed in a controlled env, then the named function is returned. No external or encoded input is involved.
info ~~critical~~ → info by review dynamic-import lib/sqlalchemy/util/langhelpers.py:361:19

`__import__` called on a non-literal expression (ast pass, confidence 0.70)
```
        def load():
            mod = __import__(modulepath)
            for token in modulepath.split(".")[1:]:
                mod = getattr(mod, token)
```
likely benign LLM, confidence 0.85 Lazy loader that imports a dotted module path and resolves attributes on it.
Reasoning
The module path comes from a lazy-loading helper that imports a dotted module path given by the library's own code, then walks attributes. The critical severity is overstated for a deferred-import utility.
info ~~warn~~ → info by review dynamic-execution lib/sqlalchemy/util/langhelpers.py:959:9

`exec` called on a non-literal expression (ast pass, confidence 0.70)
```
        )
        exec(py, env)
        try:
            env[method].__defaults__ = fn.__defaults__
```
likely benign LLM, confidence 0.90 exec of generated method source to create a wrapper that preserves defaults.
Reasoning
exec compiles generated method source, then copies defaults from the original function onto the new method. This is a standard decorator-generation technique with no sign of hidden payload.
info ~~critical~~ → info by review frame-introspection lib/sqlalchemy/util/langhelpers.py:1851:17

`sys._getframe` — call-stack frame introspection — file also calls `sys.exit`/`exec`/`eval` (anti-analysis shape) (ast pass, confidence 0.85)
```
    try:
        frame = sys._getframe(stacklevel)
    except ValueError:
        # being called from less than 3 (or given) stacklevels, weird,
```
likely benign LLM, confidence 0.90 Walks up the call stack to find the caller location for warnings.
Reasoning
sys._getframe(stacklevel) is used to find the caller for warning or deprecation messages, with a ValueError fallback. The anti-analysis tag is a false association with sys.exit/exec in the same file; the frame use is ordinary.
info ~~warn~~ → info by review dynamic-execution lib/sqlalchemy/util/langhelpers.py:1957:5

`exec` called on a non-literal expression (ast pass, confidence 0.70)
```
    env = locals().copy()
    exec(code, env)
    return env["set"]
```
likely benign LLM, confidence 0.85 exec of generated source that returns a named helper from a local namespace.
Reasoning
exec runs generated source for a set-like helper using a copied locals env, then returns the named entry. This is a code-generation idiom, not an encoded or hidden payload.
info ~~critical~~ → info by review dynamic-import lib/sqlalchemy/util/preloaded.py:140:17

`__import__` called on a non-literal expression (ast pass, confidence 0.70)
```
            ) and key not in self.__dict__:
                __import__(module, globals(), locals())
                self.__dict__[key] = globals()[key] = sys.modules[module]
```
likely benign LLM, confidence 0.90 Lazy import of a known SQLAlchemy submodule that caches the result on first access.
Reasoning
This is a lazy module loader that calls __import__ on a fixed module name from the library's own registry, then caches the result. Critical severity is not warranted for a standard deferred-import pattern.
info ~~warn~~ → info by review dynamic-attribute lib/sqlalchemy/util/preloaded.py:141:38

reach-by-name through `globals` (ast pass, confidence 0.60)
```
                __import__(module, globals(), locals())
                self.__dict__[key] = globals()[key] = sys.modules[module]
```
likely benign LLM, confidence 0.90 Caches a lazily imported module into globals and the instance dict by name.
Reasoning
globals()[key] is used to cache the lazily imported module under its attribute name. This is a normal module-level caching technique and the keys are internal.
info ~~warn~~ → info by review dynamic-execution lib/sqlalchemy/util/typing.py:274:26

`eval` called on a non-literal expression (ast pass, confidence 0.70)
```
            annotation = eval(expression, cls_namespace, locals_)
        else:
            annotation = eval(expression, base_globals, locals_)
```
likely benign LLM, confidence 0.85 eval of a string type annotation against class or module namespaces.
Reasoning
eval resolves string type annotations (forward references) against class and module namespaces. This is the standard mechanism for resolving PEP 563 annotations, and the expression comes from annotations in source code.
info ~~warn~~ → info by review dynamic-execution lib/sqlalchemy/util/typing.py:276:26

`eval` called on a non-literal expression (ast pass, confidence 0.70)
```
        else:
            annotation = eval(expression, base_globals, locals_)
    except Exception as err:
        raise NameError(
```
likely benign LLM, confidence 0.85 eval of a string annotation against base globals with error wrapping.
Reasoning
Same forward-reference resolution as the adjacent eval, using base globals. The expression is a type annotation string, and the surrounding code wraps failures in a NameError.
info ~~warn~~ → info by review dynamic-execution test/base/test_typing_utils.py:249:5

`exec` called on a non-literal expression (ast pass, confidence 0.70)
```
    scope = {}
    exec(code, None, scope)
    if len(vars) == 1:
        return scope[vars[0]]
```
likely benign LLM, confidence 0.85 Test helper that execs a locally built code snippet to obtain typing variables.
Reasoning
This test helper exec's a code string it constructs in a fresh scope to check typing behavior. It is test scaffolding, and the code is authored in the test file itself.
info ~~critical~~ → info by review dynamic-execution test/conftest.py:52:12

`compile` at module scope (runs on import) on a non-literal expression (ast pass, confidence 0.80)
```
with open(bootstrap_file) as f:
    code = compile(f.read(), "bootstrap.py", "exec")
    to_bootstrap = "pytest"
    exec(code, globals(), locals())
```
likely benign LLM, confidence 0.80 Compiles and executes a bootstrap file read from the repo at conftest import time.
Reasoning
conftest reads bootstrap.py from the repository and compiles it, then runs it. This is the known bootstrap pattern in SQLAlchemy's test suite, which loads a file that lives in the repo. Module-scope execution is unusual but the source is local and not fetched or decoded from a blob.
info ~~critical~~ → info by review dynamic-execution test/conftest.py:54:5

`exec` at module scope (runs on import) on a non-literal expression (ast pass, confidence 0.80)
```
    to_bootstrap = "pytest"
    exec(code, globals(), locals())
    from sqla_pytestplugin import *  # noqa
```
likely benign LLM, confidence 0.80 Executes the repo-local bootstrap code at conftest import to set up the pytest plugin.
Reasoning
The exec runs the repo-local bootstrap code compiled just before. Module-scope execution is intentional for test-plugin setup. The source is a checked-in file, not a remote or encoded payload.
info ~~warn~~ → info by review dynamic-execution test/dialect/mysql/test_types.py:202:29

`eval` called on a non-literal expression (ast pass, confidence 0.70)
```
        # test that repr() copies out all arguments
        self.assert_compile(eval("mysql.%r" % type_inst), res)

    @testing.combinations(
```
likely benign LLM, confidence 0.90 Test evaluates a repr string of a MySQL type to verify round-tripping.
Reasoning
eval of a formatted repr of a type instance in a test checks that repr round-trips. The input is a test-controlled object, not external data.
info ~~critical~~ → info by review dynamic-import test/dialect/postgresql/test_dialect.py:1270:40

`__import__` called on a non-literal expression (ast pass, confidence 0.70)
```
        if psycopg.__version__.startswith("3"):
            TransactionRollbackError = __import__(
                "%s.errors" % psycopg.__name__
            ).errors.TransactionRollback
```
likely benign LLM, confidence 0.90 Imports psycopg's errors submodule to reference a transaction exception class in a test.
Reasoning
__import__ loads the psycopg errors submodule by name derived from the already-imported psycopg module, to get the TransactionRollback exception class. This is a version-compatibility import in a test.
info ~~critical~~ → info by review dynamic-import test/dialect/postgresql/test_dialect.py:1274:40

`__import__` called on a non-literal expression (ast pass, confidence 0.70)
```
        else:
            TransactionRollbackError = __import__(
                "%s.extensions" % psycopg.__name__
            ).extensions.TransactionRollbackError
```
likely benign LLM, confidence 0.90 Test-only dynamic import of psycopg's extensions module to get an exception class.
Reasoning
The __import__ call builds the module name from psycopg.__name__ to fetch TransactionRollbackError. This is a standard way to resolve an optional driver submodule in a test, and the input is not attacker-controlled.
info ~~critical~~ → info by review dynamic-import test/dialect/test_all.py:9:21

`__import__` called on a non-literal expression (ast pass, confidence 0.70)
```
        return [
            getattr(__import__("sqlalchemy.dialects.%s" % d).dialects, d)
            for d in dialects.__all__
            if not d.startswith("_")
```
likely benign LLM, confidence 0.90 Test helper that imports every SQLAlchemy dialect package by name.
Reasoning
The module name is formatted from the known dialect names in sqlalchemy.dialects.__all__. This is a test helper enumerating its own package's dialects, with no external input.
info ~~warn~~ → info by review dynamic-execution test/engine/test_parseconnect.py:527:13

`exec` called on a non-literal expression (ast pass, confidence 0.70)
```
        ):
            exec(
                "from sqlalchemy.dialects import %s\ndialect = "
                "%s.dialect()" % (name, name),
```
likely benign LLM, confidence 0.85 Test exec of a templated dialect import and instantiation.
Reasoning
The exec'd code is a fixed template that imports a dialect module and instantiates it, parameterized by the dialect name from the test's own parameter list. It is typical test scaffolding.
info ~~warn~~ → info by review decoder-import-with-exec test/ext/test_associationproxy.py:859:21

file imports decoder module(s) pickle and calls `exec`/`eval`/`compile` — multi-stage payload shape (ast pass, confidence 0.80)
```
                    exec("p.children %s other" % op)
                    exec("control %s other" % op)
```
likely benign LLM, confidence 0.80 Test file exec'ing operator expressions that also imports pickle.
Reasoning
The file imports pickle, which is ordinary for serialization tests. The exec calls build Python comparison expressions from a fixed set of operators in the test itself, so the decoder-plus-exec shape is a coincidence of test content, not a payload chain.
info ~~warn~~ → info by review dynamic-execution test/ext/test_associationproxy.py:859:21

`exec` called on a non-literal expression (ast pass, confidence 0.70)
```
                    exec("p.children %s other" % op)
                    exec("control %s other" % op)
```
likely benign LLM, confidence 0.85 Test exec of a comparison expression assembled from a loop operator.
Reasoning
The exec string is built from a fixed operator in the test's own loop over comparison operators. It evaluates test-authored expressions with no external input.
info ~~warn~~ → info by review dynamic-execution test/ext/test_associationproxy.py:860:21

`exec` called on a non-literal expression (ast pass, confidence 0.70)
```
                    exec("p.children %s other" % op)
                    exec("control %s other" % op)

                    try:
```
likely benign LLM, confidence 0.85 Test exec of a comparison expression built from a loop operator.
Reasoning
Same pattern as the sibling exec in this loop: a test-authored comparison expression is built from a fixed operator set. No untrusted data reaches it.
info ~~warn~~ → info by review dynamic-execution test/orm/test_inspect.py:513:9

`exec` called on a non-literal expression (ast pass, confidence 0.70)
```
        exec(code, glbls)
        return names, glbls[clsname]
```
likely benign LLM, confidence 0.85 Test exec that defines a dynamically generated class fixture.
Reasoning
The code string is generated within the test to declare a class with the expected names, and it is exec'd into a local globals dict. This is a common technique for building dynamic test fixtures.
info ~~critical~~ → info by review dynamic-execution test/perf/orm2010.py:167:9

`os.system` called on a non-literal command — runtime-determined shell invocation (ast pass, confidence 0.85)
```
    if runsnake:
        os.system("runsnake %s" % filename)
```
likely benign LLM, confidence 0.80 Perf script that launches the runsnake profiler viewer on a output file.
Reasoning
This is a developer-run performance script that shells out to runsnake with a filename, which is most likely a command-line argument. The risk is limited to whoever runs the script, and the code does nothing hidden.
info ~~warn~~ → info by review dynamic-execution test/sql/test_lambdas.py:2220:9

`exec` called on a non-literal expression (ast pass, confidence 0.70)
```
        d = {"A": A, "__name__": "lambda_fake"}
        exec(code, d)
        generate_lambda_stmt = d["generate_lambda_stmt"]
```
likely benign LLM, confidence 0.85 Test exec that builds a generated lambda-statement function.
Reasoning
The exec'd code is generated in the test to build a lambda-statement generator, and its namespace is a local dict. This is a deliberate fixture for testing lambda SQL construction.

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/sqlalchemy/sqlalchemy sqlalchemy && cd sqlalchemy
git checkout rel_2_0_55
disclude scan --severity info --diff rel_2_0_54 .