Ordered by severity, then signals introduced in this release. Hidden characters are shown as ⟨U+…⟩.
-
`execv` called with a non-literal path (ast pass, confidence 0.90)
execv(ptr, (const char * const *)(newargs));
return fail("Could not exec %s", ptr);
}
likely benign
LLM, confidence 0.60
A C launcher calls execv on a computed path to start the GUI binary.
Reasoning
execv with a runtime-determined path in a GUI launcher is a common legitimate pattern for launching a bundled binary; the path source is not shown, so it cannot be fully confirmed benign, but nothing in the snippet is obfuscated.
-
`os.popen` called on a non-literal command — runtime-determined shell invocation (ast pass, confidence 0.85)
out = os.popen(q_cmd)
try:
binary_rpms = []
likely benign
LLM, confidence 0.85
Runs an rpm query command via os.popen during RPM packaging.
Reasoning
os.popen on a constructed rpm query command is standard distutils behavior for querying rpm; the command is built from the build configuration, not from untrusted input in this snippet.
-
`subprocess.getoutput` called with a literal shell command (ast pass, confidence 0.70)
vendor_hook = subprocess.getoutput('rpm --eval %{__os_install_post}')
likely benign
LLM, confidence 0.92
Fetches the RPM __os_install_post macro using a literal shell command.
Reasoning
A fixed literal rpm --eval command via subprocess.getoutput is an ordinary, documented RPM-vendor detection step.
-
`eval` called on a non-literal expression (ast pass, confidence 0.70)
expected = '"static", "shared", "dylib", "xcode_stub"'
if lib_type not in eval(expected):
raise ValueError(f"'lib_type' must be {expected}")
fmt = getattr(self, lib_type + "_lib_format")
likely benign
LLM, confidence 0.85
Evaluates a hardcoded string of library type names to validate lib_type.
Reasoning
eval is applied to a constant string literal defined in the same function, a known idiom for parsing a fixed list; no external input reaches it.
-
`exec` called on a non-literal expression (ast pass, confidence 0.70)
code = f.read().replace(r'\r\n', r'\n')
exec(code, g) finally:
sys.argv = save_argv
likely benign
LLM, confidence 0.85
Executes the user's setup.py script inside run_setup.
Reasoning
Executing the setup script is the documented purpose of distutils run_setup; the exec is intentional and annotated as such.
-
`__import__` called on a non-literal expression (ast pass, confidence 0.70)
try:
__import__(module_name)
module = sys.modules[module_name]
except ImportError:
likely benign
LLM, confidence 0.85
Dynamically imports a command module by name.
Reasoning
__import__ of a module name for command loading is standard plugin/command resolution in distutils, wrapped in ImportError handling.
-
identifier `Dεbug` mixes scripts: Latin + Greek (in string/comment) (raw pass, confidence 0.40)
caplog.set_level(logging.DEBUG)
log.debug('Dεbug\tMėssãge')
log.fatal('Fαtal\tÈrrōr')
assert caplog.messages == ['Dεbug\tMėssãge', 'Fαtal\tÈrrōr']
-
identifier `Fαtal` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)
log.debug('Dεbug\tMėssãge')
log.fatal('Fαtal\tÈrrōr')
assert caplog.messages == ['Dεbug\tMėssãge', 'Fαtal\tÈrrōr']
-
identifier `Fαtal` mixes scripts: Latin + Greek (in string/comment) (raw pass, confidence 0.40)
log.debug('Dεbug\tMėssãge')
log.fatal('Fαtal\tÈrrōr')
assert caplog.messages == ['Dεbug\tMėssãge', 'Fαtal\tÈrrōr']
-
identifier `Dεbug` mixes scripts: Latin + Greek (in string/comment) (raw pass, confidence 0.40)
log.fatal('Fαtal\tÈrrōr')
assert caplog.messages == ['Dεbug\tMėssãge', 'Fαtal\tÈrrōr']
-
identifier `Fαtal` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)
log.fatal('Fαtal\tÈrrōr')
assert caplog.messages == ['Dεbug\tMėssãge', 'Fαtal\tÈrrōr']
-
identifier `Fαtal` mixes scripts: Latin + Greek (in string/comment) (raw pass, confidence 0.40)
log.fatal('Fαtal\tÈrrōr')
assert caplog.messages == ['Dεbug\tMėssãge', 'Fαtal\tÈrrōr']
-
`compile` called on a non-literal expression (ast pass, confidence 0.70)
log.info("byte-compiling %s to %s", file, cfile_base)
compile(file, cfile, dfile)
else:
log.debug("skipping byte-compilation of %s to %s", file, cfile_base)
likely benign
LLM, confidence 0.85
Byte-compiles Python source files during install.
Reasoning
compile() is used to byte-compile library source files during installation, a normal distutils operation.
-
file imports decoder module(s) zlib, bz2, lzma, gzip and calls `.decompress()` — embedded payload decompressed at runtime (ast pass, confidence 0.75)
likely benign
LLM, confidence 0.85
Creates a zlib decompressor for reading compressed tar streams.
Reasoning
Streaming decompression via decompressobj is the core of tarfile's compressed stream handling; it decompresses the archive being read, not an embedded payload.
-
`eval` called on a non-literal expression (ast pass, confidence 0.70)
try:
return eval(use)
except TypeError:
return replace
likely benign
LLM, confidence 0.80
Evaluates an expression string in a utility wrapper.
Reasoning
eval of a 'use' expression in a retry/replace helper is a legacy pattern that is unsafe only if the expression is attacker-controlled; the snippet shows no such source, so it is a code-quality concern rather than clear malice.
-
`compile` called on a non-literal expression (ast pass, confidence 0.70)
try:
compile(python_expression, "", "eval")
except SyntaxError:
message = f"Invalid license expression: {raw_license_expression!r}"
likely benign
LLM, confidence 0.90
Syntax-checks a license expression by compiling it without running it.
Reasoning
compile with mode 'eval' is used purely to validate syntax of a license expression and discards the result; it does not execute the code.
-
`exec` called on a non-literal expression (ast pass, confidence 0.70)
try:
exec(code, locals()) except SystemExit as e:
if e.code:
likely benign
LLM, confidence 0.85
Runs setup.py code during the PEP 517 build.
Reasoning
build_meta executes the project's setup.py as part of the PEP 517 build backend; exec is the intended, documented behavior and is annotated.
-
`marshal.load` deserializes Python bytecode from bytes — code-object sink (ast pass, confidence 0.75)
f.read(skip)
code = marshal.load(f)
f.close()
safe = True
likely benign
LLM, confidence 0.80
Reads a compiled module's code object while building an egg.
Reasoning
marshal.load reads bytecode from a module file during egg-building to detect whether it is safe, a known legitimate use with no hidden payload shown.
-
`inspect.getouterframes` — call-stack frame introspection (ast pass, confidence 0.70)
frames = inspect.getouterframes(run_frame)
for frame in frames[2:4]:
(caller,) = frame[:1]
likely benign
LLM, confidence 0.90
Inspects the call stack to locate the calling frame.
Reasoning
Call-stack introspection to find the caller of run_setup for install-command handling is a benign use of inspect in setuptools.
-
line length 1035 characters (raw pass, confidence 0.50)
raise JsonSchemaValueException("" + (name_prefix or "data") + ".build-system must be object", value=data__buildsystem, name="" + (name_prefix or "data") + ".build-system", definition={'type': 'object', 'description': 'Table used to store build-related data', 'additionalProperties': False, 'properties':
-
line length 792 characters (raw pass, confidence 0.50)
raise JsonSchemaValueException("" + (name_prefix or "data") + ".dependency-groups must be object", value=data__dependencygroups, name="" + (name_prefix or "data") + ".dependency-groups", definition={'type': 'object', 'description': 'Dependency groups following PEP 735', 'additionalProperties': False, 'p
-
line length 891 characters (raw pass, confidence 0.50)
raise JsonSchemaValueException("" + (name_prefix or "data") + ".package-dir must be object", value=data__packagedir, name="" + (name_prefix or "data") + ".package-dir", definition={'$$description': [':class:`dict`-like structure mapping from package names to directories where their', 'code can be found.
-
line length 968 characters (raw pass, confidence 0.50)
raise JsonSchemaValueException("" + (name_prefix or "data") + ".package-data must be object", value=data__packagedata, name="" + (name_prefix or "data") + ".package-data", definition={'$$description': ['Mapping from package names to lists of glob patterns.', 'Usually this option is not needed when using
-
line length 934 characters (raw pass, confidence 0.50)
raise JsonSchemaValueException("" + (name_prefix or "data") + ".exclude-package-data must be object", value=data__excludepackagedata, name="" + (name_prefix or "data") + ".exclude-package-data", definition={'$$description': ['Mapping from package names to lists of glob patterns that should be excluded',
-
line length 1720 characters (raw pass, confidence 0.50)
raise JsonSchemaValueException("" + (name_prefix or "data") + ".ext-modules must be array", value=data__extmodules, name="" + (name_prefix or "data") + ".ext-modules", definition={'description': 'Extension modules to be compiled by setuptools', 'type': 'array', 'items': {'$id': '#/definitions/ext-module
-
line length 791 characters (raw pass, confidence 0.50)
raise JsonSchemaValueException("" + (name_prefix or "data") + ".data-files must be object", value=data__datafiles, name="" + (name_prefix or "data") + ".data-files", definition={'$$description': ['``dict``-like structure where each key represents a directory and', 'the value is a list of glob patterns t
-
line length 1584 characters (raw pass, confidence 0.50)
raise JsonSchemaValueException("" + (name_prefix or "data") + " must be object", value=data, name="" + (name_prefix or "data") + "", definition={'$id': '#/definitions/ext-module', 'title': 'Extension module', 'description': 'Parameters to construct a :class:`setuptools.Extension` object', 'type': 'object', 'req
-
line length 1643 characters (raw pass, confidence 0.50)
raise JsonSchemaValueException("" + (name_prefix or "data") + " must contain " + (str(sorted(data__missing_keys)) + " properties"), value=data, name="" + (name_prefix or "data") + "", definition={'$id': '#/definitions/ext-module', 'title': 'Extension module', 'description': 'Parameters to construct a :class
-
line length 1636 characters (raw pass, confidence 0.50)
raise JsonSchemaValueException("" + (name_prefix or "data") + " must not contain "+str(data_keys)+" properties", value=data, name="" + (name_prefix or "data") + "", definition={'$id': '#/definitions/ext-module', 'title': 'Extension module', 'description': 'Parameters to construct a :class:`setuptools.Extens
-
line length 1230 characters (raw pass, confidence 0.50)
raise JsonSchemaValueException("" + (name_prefix or "data") + " must be object", value=data, name="" + (name_prefix or "data") + "", definition={'$id': '#/definitions/find-directive', 'title': "'find:' directive", 'type': 'object', 'additionalProperties': False, 'properties': {'find': {'type': 'object', '$$desc
-
line length 1110 characters (raw pass, confidence 0.50)
raise JsonSchemaValueException("" + (name_prefix or "data") + ".find must be object", value=data__find, name="" + (name_prefix or "data") + ".find", definition={'type': 'object', '$$description': ['Dynamic `package discovery', '<https://setuptools.pypa.io/en/latest/userguide/package_discovery.html>`_.']
-
line length 1282 characters (raw pass, confidence 0.50)
raise JsonSchemaValueException("" + (name_prefix or "data") + " must not contain "+str(data_keys)+" properties", value=data, name="" + (name_prefix or "data") + "", definition={'$id': '#/definitions/find-directive', 'title': "'find:' directive", 'type': 'object', 'additionalProperties': False, 'properties':
-
line length 1502 characters (raw pass, confidence 0.50)
raise JsonSchemaValueException("" + (name_prefix or "data") + ".readme must be valid exactly by one definition" + (" (" + str(data__readme_one_of_count12) + " matches found)"), value=data__readme, name="" + (name_prefix or "data") + ".readme", definition={'$$description': ['`Full/detailed description of
-
line length 935 characters (raw pass, confidence 0.50)
raise JsonSchemaValueException("" + (name_prefix or "data") + ".license must be valid exactly by one definition" + (" (" + str(data__license_one_of_count14) + " matches found)"), value=data__license, name="" + (name_prefix or "data") + ".license", definition={'description': '`Project license <https://pe
-
line length 963 characters (raw pass, confidence 0.50)
raise JsonSchemaValueException("" + (name_prefix or "data") + ".authors must be array", value=data__authors, name="" + (name_prefix or "data") + ".authors", definition={'type': 'array', 'items': {'$id': '#/definitions/author', 'title': 'Author or Maintainer', '$comment': 'https://peps.python.org/pep-062
-
line length 920 characters (raw pass, confidence 0.50)
raise JsonSchemaValueException("" + (name_prefix or "data") + ".maintainers must be array", value=data__maintainers, name="" + (name_prefix or "data") + ".maintainers", definition={'type': 'array', 'items': {'$id': '#/definitions/author', 'title': 'Author or Maintainer', '$comment': 'https://peps.python
-
line length 837 characters (raw pass, confidence 0.50)
raise JsonSchemaValueException("" + (name_prefix or "data") + ".dynamic[{data__dynamic_x}]".format(**locals()) + " must be one of ['version', 'description', 'readme', 'requires-python', 'license', 'license-files', 'authors', 'maintainers', 'keywords', 'classifiers', 'urls', 'scripts', 'gui-scrip
-
line length 968 characters (raw pass, confidence 0.50)
raise JsonSchemaValueException("" + (name_prefix or "data") + " must be object", value=data, name="" + (name_prefix or "data") + "", definition={'$id': '#/definitions/entry-point-group', 'title': 'Entry-points', 'type': 'object', '$$description': ['Entry-points are grouped together to indicate what sort of capa
-
line length 1020 characters (raw pass, confidence 0.50)
raise JsonSchemaValueException("" + (name_prefix or "data") + " must not contain "+str(data_keys)+" properties", value=data, name="" + (name_prefix or "data") + "", definition={'$id': '#/definitions/entry-point-group', 'title': 'Entry-points', 'type': 'object', '$$description': ['Entry-points are grouped to
-
line length 1011 characters (raw pass, confidence 0.50)
raise JsonSchemaValueException("" + (name_prefix or "data") + " must be named by propertyName definition", value=data, name="" + (name_prefix or "data") + "", definition={'$id': '#/definitions/entry-point-group', 'title': 'Entry-points', 'type': 'object', '$$description': ['Entry-points are grouped toge
-
`marshal.load` deserializes Python bytecode from bytes — code-object sink (ast pass, confidence 0.75)
f.read(8) code = marshal.load(f)
elif kind == PY_FROZEN:
code = _imp.get_frozen_object(module, paths)
likely benign
LLM, confidence 0.80
Reads bytecode from a module file to inspect its constants.
Reasoning
marshal.load is used to read a module's bytecode to extract its version constant, a standard operation in setuptools' dependency detection on local files.
-
file imports decoder module(s) marshal and calls `exec`/`eval`/`compile` — multi-stage payload shape (ast pass, confidence 0.80)
elif kind == PY_SOURCE:
code = compile(f.read(), path, 'exec')
else:
likely benign
LLM, confidence 0.90
Compiles Python source files read from disk while inspecting module metadata in setuptools' dependency checker.
Reasoning
The snippet shows compile() of source read from a file on the PY_SOURCE branch, which is how setuptools inspects module constants. The marshal import is consistent with handling bytecode for the same feature. This is a legitimate introspection pattern, and the multi-stage label is a heuristic false positive on a generic import helper.
-
`compile` called on a non-literal expression (ast pass, confidence 0.70)
elif kind == PY_SOURCE:
code = compile(f.read(), path, 'exec')
else:
likely benign
LLM, confidence 0.90
compile() on source text read from a local module file during dependency introspection.
Reasoning
compile() receives the contents of a file it just opened, along with its path and mode 'exec'. This is the normal way to load source for inspection. Nothing in the snippet is encoded, hidden, or fetched remotely.
-
`__import__` called on a non-literal expression (ast pass, confidence 0.70)
__import__(cython_impl, fromlist=['build_ext']).build_ext except Exception: return False
likely benign
LLM, confidence 0.85
Dynamic __import__ of the Cython build_ext module to test whether Cython support is available.
Reasoning
The import is a deliberate feature check for the optional Cython build_ext. The comment explains that it is evaluated to trigger validation, and the broad except returns False when the import fails. The module name is internal to setuptools, and the critical severity comes from the dynamic-import pattern alone.
-
`compile` called on a non-literal expression (ast pass, confidence 0.70)
norm_script = script.replace('\\r\\n', '\\n')
code = compile(norm_script, script_name, 'exec')
exec(code, namespace)
likely benign
LLM, confidence 0.90
Compiles and executes a script inside a namespace in setuptools' launch helper, which is its intended purpose.
Reasoning
This is the setuptools launcher, which runs a script it was given. The compile and exec are intentional, as the noqa comment says, and the script comes from the caller. Newline normalization is ordinary preparation before compiling.
-
`exec` called on a non-literal expression (ast pass, confidence 0.70)
code = compile(norm_script, script_name, 'exec')
exec(code, namespace)
likely benign
LLM, confidence 0.90
exec of the compiled script code inside setuptools' launch helper.
Reasoning
exec runs the code object compiled on the previous line, with an explicit namespace and a noqa comment marking it as intentional. This is the expected behavior of a script launcher.
-
identifier `Γαμα` contains homoglyph candidates: α (03B1)→a, α (03B1)→a (in string/comment) (raw pass, confidence 0.35)
{name = "John X. Ãørçeč", email = "john@utf8.org"},
{name = "Γαμα קּ 東", email = "gama@utf8.org"},
]
classifiers = [
-
identifier `Γαμα` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)
{name = "John X. Ãørçeč", email = "john@utf8.org"},
{name = "Γαμα קּ 東", email = "gama@utf8.org"},
]
classifiers = [
-
identifier `Γαμα` contains homoglyph candidates: α (03B1)→a, α (03B1)→a (in string/comment) (raw pass, confidence 0.35)
'Brett Cannon <brett@python.org>, "John X. Ãørçeč" <john@utf8.org>, '
'Γαμα קּ 東 <gama@utf8.org>'
),
id='non-international-emails',
-
identifier `Γαμα` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)
'Brett Cannon <brett@python.org>, "John X. Ãørçeč" <john@utf8.org>, '
'Γαμα קּ 東 <gama@utf8.org>'
),
id='non-international-emails',
-
identifier `Γαμα` contains homoglyph candidates: α (03B1)→a, α (03B1)→a (in string/comment) (raw pass, confidence 0.35)
version = 42
author_email = "John X. Ãørçeč" <john@utf8.org>, Γαμα קּ 東 <gama@utf8.org>
long_description = file: README.rst
-
identifier `Γαμα` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)
version = 42
author_email = "John X. Ãørçeč" <john@utf8.org>, Γαμα קּ 東 <gama@utf8.org>
long_description = file: README.rst
-
identifier `Γαμα` contains homoglyph candidates: α (03B1)→a, α (03B1)→a (in string/comment) (raw pass, confidence 0.35)
Version: 42
Author-email: "John X. Ãørçeč" <john@utf8.org>, Γαμα קּ 東 <gama@utf8.org>
-
identifier `Γαμα` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)
Version: 42
Author-email: "John X. Ãørçeč" <john@utf8.org>, Γαμα קּ 東 <gama@utf8.org>
-
identifier `Γαμα` contains homoglyph candidates: α (03B1)→a, α (03B1)→a (in string/comment) (raw pass, confidence 0.35)
assert 'Author-email: "John X. Ãørçeč"' in metadata
assert "Γαμα קּ 東 " in metadata
assert "UTF-8 描述 説明" in metadata
-
identifier `Γαμα` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)
assert 'Author-email: "John X. Ãørçeč"' in metadata
assert "Γαμα קּ 東 " in metadata
assert "UTF-8 描述 説明" in metadata
-
`__import__` called on a non-literal expression (ast pass, confidence 0.70)
return importlib.__import__(name, *args, **kwargs)
with suppress(KeyError):
likely benign
LLM, confidence 0.90
Test helper that forwards import calls to importlib.__import__ so the test can observe or patch them.
Reasoning
The function is a test helper that forwards to importlib.__import__ with the same arguments, probably to mock or observe imports. It sits inside a with-suppress block in a test file. The critical rating is a false positive driven by the dynamic-import signal.
-
`exec` called on a non-literal expression (ast pass, confidence 0.70)
loc = {}
exec(finder, loc, loc) loc["install"]()
likely benign
LLM, confidence 0.90
Test that execs the generated editable-install finder code in a local namespace and calls its install function.
Reasoning
This is a test for editable installs. It executes a generated finder script in a local dict and then calls its install function, which is a standard way to test the generated code. The code is not obfuscated and is limited to test scope.
-
`eval` called on a non-literal expression (ast pass, confidence 0.70)
raw_req,
(req for req in reqs if for_extra(req) and eval(req, extra=extra)),
)
)
likely benign
LLM, confidence 0.80
Evaluates requirement environment markers with an extra name while filtering wheel dependencies.
Reasoning
The eval is applied to requirement marker strings during wheel metadata processing, with an extra keyword that carries the extra name. This is the marker-evaluation path, and the eval target is a requirement string from package metadata. It is a known pattern in setuptools, but eval on metadata strings is worth noting, so confidence is moderate.
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.
disclude.io