openai 3.36.1

Source: https://github.com/openai/openai-python
Artifact scanned: openai-3.36.1-py3-none-any.whl (wheel · 2.2 MB · SHA-256 4c15b6765fe1…)
Compared with: openai-3.36.0-py3-none-any.whl (0 signals introduced since)
Files: 1999 scanned, 7 skipped (binary, oversized, or unrecognised)
Signals: 0 critical · 0 warn · 44 info
Scan time: 27.2 s
LLM review: Reviewed by claude-haiku-5-5 (Anthropic): 44 of 44 warn and critical signals; 44 demoted to info.
Disclude version: 4.3.0
Scanned (UTC): 2026-10-23 04:10

Signals

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

info ~~warn~~ → info by review dynamic-attribute openai/__init__.py:139:13

reach-by-name through `globals` (ast pass, confidence 0.60)
```
            value = getattr(import_module(module, __name__), name)
            globals()[name] = value
            return value
        raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
```
likely benign LLM, confidence 0.95 Lazy submodule loader in the openai package's module-level __getattr__.
Reasoning
Standard lazy-loading __getattr__ pattern: imports a submodule by name from within the package, caches it in globals, and raises AttributeError otherwise. Only package-relative imports are involved, no external input or execution.
info ~~warn~~ → info by review dynamic-attribute openai/lib/streaming/__init__.py:19:13

reach-by-name through `globals` (ast pass, confidence 0.60)
```
            value = getattr(import_module("._assistants", __name__), name)
            globals()[name] = value
            return value
        raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
```
likely benign LLM, confidence 0.95 Lazy submodule loader for streaming helpers in the openai SDK.
Reasoning
Same lazy-import __getattr__ pattern, importing a relative submodule ._assistants and caching the attribute in globals. Legitimate lazy loading.
info ~~warn~~ → info by review dynamic-attribute openai/resources/__init__.py:350:9

reach-by-name through `globals` (ast pass, confidence 0.60)
```
            raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
        globals()[name] = value
        return value
```
likely benign LLM, confidence 0.95 Lazy resource attribute resolver in the openai resources package.
Reasoning
Standard module __getattr__ lazy-loading tail that caches the resolved attribute in globals and raises AttributeError on miss. Consistent with the SDK's generated resource packages.
info ~~warn~~ → info by review dynamic-attribute openai/resources/admin/__init__.py:53:9

reach-by-name through `globals` (ast pass, confidence 0.60)
```
            raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
        globals()[name] = value
        return value
```
likely benign LLM, confidence 0.95 Lazy attribute resolver for the openai admin resources package.
Reasoning
Identical lazy __getattr__ caching pattern for an admin subpackage; no external input or execution beyond importing package modules.
info ~~warn~~ → info by review dynamic-attribute openai/resources/admin/organization/__init__.py:233:9

reach-by-name through `globals` (ast pass, confidence 0.60)
```
            raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
        globals()[name] = value
        return value
```
likely benign LLM, confidence 0.95 Lazy attribute resolver for organization admin resources.
Reasoning
Same generated lazy-loading __getattr__ pattern for nested organization resources; benign.
info ~~warn~~ → info by review dynamic-attribute openai/resources/admin/organization/groups/__init__.py:68:9

reach-by-name through `globals` (ast pass, confidence 0.60)
```
            raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
        globals()[name] = value
        return value
```
likely benign LLM, confidence 0.95 Lazy attribute resolver for organization groups resources.
Reasoning
Generated lazy-loading __getattr__ caching pattern; no dynamic code execution or external data.
info ~~warn~~ → info by review dynamic-attribute openai/resources/admin/organization/projects/__init__.py:230:9

reach-by-name through `globals` (ast pass, confidence 0.60)
```
            raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
        globals()[name] = value
        return value
```
likely benign LLM, confidence 0.95 Lazy attribute resolver for organization projects resources.
Reasoning
Standard lazy-import __getattr__ caching into globals for project resources; benign.
info ~~warn~~ → info by review dynamic-attribute openai/resources/admin/organization/projects/groups/__init__.py:53:9

reach-by-name through `globals` (ast pass, confidence 0.60)
```
            raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
        globals()[name] = value
        return value
```
likely benign LLM, confidence 0.95 Lazy attribute resolver for project groups resources.
Reasoning
Same generated lazy-loading pattern in a nested package; no suspicious behavior.
info ~~warn~~ → info by review dynamic-attribute openai/resources/admin/organization/projects/service_accounts/__init__.py:53:9

reach-by-name through `globals` (ast pass, confidence 0.60)
```
            raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
        globals()[name] = value
        return value
```
likely benign LLM, confidence 0.95 Lazy attribute resolver for project service accounts resources.
Reasoning
Standard lazy __getattr__ caching pattern for service account resources; benign.
info ~~warn~~ → info by review dynamic-attribute openai/resources/admin/organization/projects/users/__init__.py:53:9

reach-by-name through `globals` (ast pass, confidence 0.60)
```
            raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
        globals()[name] = value
        return value
```
likely benign LLM, confidence 0.95 Lazy attribute resolver for project users resources.
Reasoning
Generated lazy-loading pattern identical to the rest of the SDK; no external input or execution.
info ~~warn~~ → info by review dynamic-attribute openai/resources/admin/organization/users/__init__.py:53:9

reach-by-name through `globals` (ast pass, confidence 0.60)
```
            raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
        globals()[name] = value
        return value
```
likely benign LLM, confidence 0.95 Lazy attribute resolver for organization users resources.
Reasoning
Standard lazy __getattr__ caching into globals for organization users; benign.
info ~~warn~~ → info by review dynamic-attribute openai/resources/audio/__init__.py:113:9

reach-by-name through `globals` (ast pass, confidence 0.60)
```
            raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
        globals()[name] = value
        return value
```
likely benign LLM, confidence 0.95 Lazy attribute resolver for audio resources.
Reasoning
Generated lazy-loading __getattr__ pattern for audio resources; standard SDK code.
info ~~warn~~ → info by review dynamic-attribute openai/resources/beta/__init__.py:113:9

reach-by-name through `globals` (ast pass, confidence 0.60)
```
            raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
        globals()[name] = value
        return value
```
likely benign LLM, confidence 0.95 Lazy attribute resolver for beta resources.
Reasoning
Same lazy-loading __getattr__ pattern for beta resources; benign.
info ~~warn~~ → info by review dynamic-attribute openai/resources/beta/agents/__init__.py:83:9

reach-by-name through `globals` (ast pass, confidence 0.60)
```
            raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
        globals()[name] = value
        return value
```
likely benign LLM, confidence 0.95 Lazy attribute resolver for beta agents resources.
Reasoning
Standard lazy __getattr__ caching in a nested beta package; no malicious indicators.
info ~~warn~~ → info by review dynamic-attribute openai/resources/beta/agents/environments/__init__.py:68:9

reach-by-name through `globals` (ast pass, confidence 0.60)
```
            raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
        globals()[name] = value
        return value
```
likely benign LLM, confidence 0.95 Lazy attribute resolver for beta agent environments resources.
Reasoning
Same generated lazy-import pattern in a deeply nested package; benign and consistent with the SDK.
info ~~warn~~ → info by review dynamic-attribute openai/resources/beta/agents/sessions/__init__.py:128:9

reach-by-name through `globals` (ast pass, confidence 0.60)
```
            raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
        globals()[name] = value
        return value
```
dismissed LLM, confidence 0.93 Module-level __getattr__ that lazily caches submodule attributes into globals.
Reasoning
This is the standard PEP 562 lazy-loading __getattr__ used in generated SDK package __init__ files. It caches a submodule attribute into globals on first access. It has no decoding, execution, or network activity and is the expected pattern in openai-python.
info ~~warn~~ → info by review dynamic-attribute openai/resources/beta/agents/sessions/subagents/__init__.py:68:9

reach-by-name through `globals` (ast pass, confidence 0.60)
```
            raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
        globals()[name] = value
        return value
```
dismissed LLM, confidence 0.93 Lazy submodule attribute resolution via globals in a generated package __init__.
Reasoning
Same generated lazy-import __getattr__ pattern as the other openai package __init__ files. It only resolves and caches attribute names within the package and has no malicious behavior.
info ~~warn~~ → info by review dynamic-attribute openai/resources/beta/agents/sessions/subagents/turns/__init__.py:53:9

reach-by-name through `globals` (ast pass, confidence 0.60)
```
            raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
        globals()[name] = value
        return value
```
dismissed LLM, confidence 0.93 Lazy attribute caching through globals in a generated SDK package __init__.
Reasoning
Standard generated lazy-loading __getattr__ storing resolved names into globals. It is a common idiom for avoiding eager imports and is benign in context.
info ~~warn~~ → info by review dynamic-attribute openai/resources/beta/agents/sessions/turns/__init__.py:53:9

reach-by-name through `globals` (ast pass, confidence 0.60)
```
            raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
        globals()[name] = value
        return value
```
dismissed LLM, confidence 0.93 Generated lazy-import __getattr__ memoizing attributes into module globals.
Reasoning
Identical generated lazy-import helper in the openai SDK. The globals write only memoizes an attribute already resolved from the package's own modules.
info ~~warn~~ → info by review dynamic-attribute openai/resources/beta/agents/vaults/__init__.py:53:9

reach-by-name through `globals` (ast pass, confidence 0.60)
```
            raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
        globals()[name] = value
        return value
```
dismissed LLM, confidence 0.93 PEP 562 lazy-loading hook caching attributes via globals.
Reasoning
Standard PEP 562 lazy loading in a generated openai resource package. The dynamic globals assignment is a deliberate caching mechanism with no execution or network behavior.
info ~~warn~~ → info by review dynamic-attribute openai/resources/beta/chatkit/__init__.py:68:9

reach-by-name through `globals` (ast pass, confidence 0.60)
```
            raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
        globals()[name] = value
        return value
```
dismissed LLM, confidence 0.93 Lazy module attribute hook in the chatkit resource package.
Reasoning
Generated openai SDK lazy-attribute pattern. The name-based globals write is a memoization step for legitimate submodule classes and is expected in this package layout.
info ~~warn~~ → info by review dynamic-attribute openai/resources/beta/responses/__init__.py:68:9

reach-by-name through `globals` (ast pass, confidence 0.60)
```
            raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
        globals()[name] = value
        return value
```
dismissed LLM, confidence 0.93 PEP 562 __getattr__ caching submodule attributes into globals.
Reasoning
Generated lazy-import __getattr__ identical to the rest of the openai package family. The reach-by-name flagged by the scanner is ordinary PEP 562 behavior.
info ~~warn~~ → info by review dynamic-attribute openai/resources/beta/threads/__init__.py:68:9

reach-by-name through `globals` (ast pass, confidence 0.60)
```
            raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
        globals()[name] = value
        return value
```
dismissed LLM, confidence 0.93 Lazy-loading module attribute hook in the threads resource package.
Reasoning
Standard generated lazy-loading helper. It resolves names the package itself defines and stores them in globals, which is a normal performance idiom with no malicious indicators.
info ~~warn~~ → info by review dynamic-attribute openai/resources/beta/threads/runs/__init__.py:53:9

reach-by-name through `globals` (ast pass, confidence 0.60)
```
            raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
        globals()[name] = value
        return value
```
dismissed LLM, confidence 0.93 Lazy submodule attribute caching in the threads runs package.
Reasoning
Generated lazy-import __getattr__ pattern in the openai SDK. The globals assignment only caches already-imported package members and is benign.
info ~~warn~~ → info by review dynamic-attribute openai/resources/chat/__init__.py:53:9

reach-by-name through `globals` (ast pass, confidence 0.60)
```
            raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
        globals()[name] = value
        return value
```
dismissed LLM, confidence 0.93 Lazy attribute resolution with globals caching in the chat package.
Reasoning
Standard generated PEP 562 lazy-loading hook in the openai chat package. The globals write is ordinary memoization and carries no obfuscation or malicious intent.
info ~~warn~~ → info by review dynamic-attribute openai/resources/chat/completions/__init__.py:53:9

reach-by-name through `globals` (ast pass, confidence 0.60)
```
            raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
        globals()[name] = value
        return value
```
dismissed LLM, confidence 0.93 Lazy-import __getattr__ caching into globals in chat completions.
Reasoning
Same generated lazy-import pattern used across the openai SDK. The name-based globals assignment only caches the package's own submodule attributes.
info ~~warn~~ → info by review dynamic-attribute openai/resources/containers/__init__.py:53:9

reach-by-name through `globals` (ast pass, confidence 0.60)
```
            raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
        globals()[name] = value
        return value
```
dismissed LLM, confidence 0.93 PEP 562 lazy attribute hook for the containers package.
Reasoning
Generated lazy-loading __getattr__ in the openai containers package. Writing resolved names into globals is a standard caching technique and benign here.
info ~~warn~~ → info by review dynamic-attribute openai/resources/containers/files/__init__.py:53:9

reach-by-name through `globals` (ast pass, confidence 0.60)
```
            raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
        globals()[name] = value
        return value
```
dismissed LLM, confidence 0.93 Lazy submodule attribute caching in the containers files package.
Reasoning
Identical generated lazy-import helper in the openai SDK. The dynamic globals write is ordinary memoization of package members, not malicious behavior.
info ~~warn~~ → info by review dynamic-attribute openai/resources/conversations/__init__.py:53:9

reach-by-name through `globals` (ast pass, confidence 0.60)
```
            raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
        globals()[name] = value
        return value
```
dismissed LLM, confidence 0.93 Lazy attribute resolution with globals caching in conversations.
Reasoning
Standard generated lazy-loading __getattr__ in the openai conversations package. The globals caching is a benign import optimization.
info ~~warn~~ → info by review dynamic-attribute openai/resources/evals/__init__.py:53:9

reach-by-name through `globals` (ast pass, confidence 0.60)
```
            raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
        globals()[name] = value
        return value
```
dismissed LLM, confidence 0.93 Lazy-loading module attribute hook in the evals package.
Reasoning
Generated PEP 562 lazy-import hook in the openai evals package. The name-based globals write is expected SDK behavior with no execution or network activity.
info ~~warn~~ → info by review dynamic-attribute openai/resources/evals/runs/__init__.py:53:9

reach-by-name through `globals` (ast pass, confidence 0.60)
```
            raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
        globals()[name] = value
        return value
```
dismissed LLM, confidence 0.93 Lazy attribute caching via globals in the evals runs package.
Reasoning
Same generated lazy-import __getattr__ used throughout the openai SDK. The globals assignment only memoizes the package's own submodule attributes and is benign.
info ~~warn~~ → info by review dynamic-attribute openai/resources/fine_tuning/__init__.py:83:9

reach-by-name through `globals` (ast pass, confidence 0.60)
```
            raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
        globals()[name] = value
        return value
```
likely benign LLM, confidence 0.93 Lazy module attribute loader in the OpenAI SDK's fine_tuning package that caches resolved names into globals().
Reasoning
The snippet is the standard PEP 562-style lazy-import __getattr__ pattern: it raises AttributeError for unknown names, then caches the loaded submodule or value in globals(). The file path places it in the openai SDK's generated resource package, where this is a common way to defer heavy imports. Nothing here decodes data, runs code from strings, or reaches the network.
info ~~warn~~ → info by review dynamic-attribute openai/resources/fine_tuning/alpha/__init__.py:53:9

reach-by-name through `globals` (ast pass, confidence 0.60)
```
            raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
        globals()[name] = value
        return value
```
likely benign LLM, confidence 0.93 Lazy module attribute loader in the OpenAI SDK's fine_tuning alpha package that caches resolved names into globals().
Reasoning
The snippet is the standard PEP 562 lazy-import __getattr__ pattern: it raises AttributeError for unknown names and caches resolved names in globals(). It sits in the generated OpenAI SDK package and does no decoding, dynamic execution, or network access.
info ~~warn~~ → info by review dynamic-attribute openai/resources/fine_tuning/checkpoints/__init__.py:53:9

reach-by-name through `globals` (ast pass, confidence 0.60)
```
            raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
        globals()[name] = value
        return value
```
likely benign LLM, confidence 0.93 Lazy module attribute loader in the OpenAI SDK's fine_tuning checkpoints package that caches resolved names into globals().
Reasoning
The snippet is the standard PEP 562 lazy-import __getattr__ pattern: it raises AttributeError for unknown names and caches resolved names in globals(). It sits in the generated OpenAI SDK package and does no decoding, dynamic execution, or network access.
info ~~warn~~ → info by review dynamic-attribute openai/resources/fine_tuning/jobs/__init__.py:53:9

reach-by-name through `globals` (ast pass, confidence 0.60)
```
            raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
        globals()[name] = value
        return value
```
likely benign LLM, confidence 0.93 Lazy module attribute loader in the OpenAI SDK's fine_tuning jobs package that caches resolved names into globals().
Reasoning
The snippet is the standard PEP 562 lazy-import __getattr__ pattern: it raises AttributeError for unknown names and caches resolved names in globals(). It sits in the generated OpenAI SDK package and does no decoding, dynamic execution, or network access.
info ~~warn~~ → info by review dynamic-attribute openai/resources/live/__init__.py:67:9

reach-by-name through `globals` (ast pass, confidence 0.60)
```
            raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
        globals()[name] = value
        return value
```
likely benign LLM, confidence 0.93 Lazy module attribute loader in the OpenAI SDK's live package that caches resolved names into globals().
Reasoning
The snippet is the standard PEP 562 lazy-import __getattr__ pattern: it raises AttributeError for unknown names and caches resolved names in globals(). It sits in the generated OpenAI SDK package and does no decoding, dynamic execution, or network access.
info ~~warn~~ → info by review dynamic-attribute openai/resources/realtime/__init__.py:83:9

reach-by-name through `globals` (ast pass, confidence 0.60)
```
            raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
        globals()[name] = value
        return value
```
likely benign LLM, confidence 0.93 Lazy module attribute loader in the OpenAI SDK's realtime package that caches resolved names into globals().
Reasoning
The snippet is the standard PEP 562 lazy-import __getattr__ pattern: it raises AttributeError for unknown names and caches resolved names in globals(). It sits in the generated OpenAI SDK package and does no decoding, dynamic execution, or network access.
info ~~warn~~ → info by review dynamic-attribute openai/resources/realtime/translations/__init__.py:53:9

reach-by-name through `globals` (ast pass, confidence 0.60)
```
            raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
        globals()[name] = value
        return value
```
likely benign LLM, confidence 0.93 Lazy module attribute loader in the OpenAI SDK's realtime translations package that caches resolved names into globals().
Reasoning
The snippet is the standard PEP 562 lazy-import __getattr__ pattern: it raises AttributeError for unknown names and caches resolved names in globals(). It sits in the generated OpenAI SDK package and does no decoding, dynamic execution, or network access.
info ~~warn~~ → info by review dynamic-attribute openai/resources/responses/__init__.py:68:9

reach-by-name through `globals` (ast pass, confidence 0.60)
```
            raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
        globals()[name] = value
        return value
```
likely benign LLM, confidence 0.93 Lazy module attribute loader in the OpenAI SDK's responses package that caches resolved names into globals().
Reasoning
The snippet is the standard PEP 562 lazy-import __getattr__ pattern: it raises AttributeError for unknown names and caches resolved names in globals(). It sits in the generated OpenAI SDK package and does no decoding, dynamic execution, or network access.
info ~~warn~~ → info by review dynamic-attribute openai/resources/safety/__init__.py:68:9

reach-by-name through `globals` (ast pass, confidence 0.60)
```
            raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
        globals()[name] = value
        return value
```
likely benign LLM, confidence 0.93 Lazy module attribute loader in the OpenAI SDK's safety package that caches resolved names into globals().
Reasoning
The snippet is the standard PEP 562 lazy-import __getattr__ pattern: it raises AttributeError for unknown names and caches resolved names in globals(). It sits in the generated OpenAI SDK package and does no decoding, dynamic execution, or network access.
info ~~warn~~ → info by review dynamic-attribute openai/resources/skills/__init__.py:68:9

reach-by-name through `globals` (ast pass, confidence 0.60)
```
            raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
        globals()[name] = value
        return value
```
likely benign LLM, confidence 0.93 Lazy module attribute loader in the OpenAI SDK's skills package that caches resolved names into globals().
Reasoning
The snippet is the standard PEP 562 lazy-import __getattr__ pattern: it raises AttributeError for unknown names and caches resolved names in globals(). It sits in the generated OpenAI SDK package and does no decoding, dynamic execution, or network access.
info ~~warn~~ → info by review dynamic-attribute openai/resources/skills/versions/__init__.py:53:9

reach-by-name through `globals` (ast pass, confidence 0.60)
```
            raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
        globals()[name] = value
        return value
```
likely benign LLM, confidence 0.93 Lazy module attribute loader in the OpenAI SDK's skills versions package that caches resolved names into globals().
Reasoning
The snippet is the standard PEP 562 lazy-import __getattr__ pattern: it raises AttributeError for unknown names and caches resolved names in globals(). It sits in the generated OpenAI SDK package and does no decoding, dynamic execution, or network access.
info ~~warn~~ → info by review dynamic-attribute openai/resources/uploads/__init__.py:53:9

reach-by-name through `globals` (ast pass, confidence 0.60)
```
            raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
        globals()[name] = value
        return value
```
likely benign LLM, confidence 0.93 Lazy module attribute loader in the OpenAI SDK's uploads package that caches resolved names into globals().
Reasoning
The snippet is the standard PEP 562 lazy-import __getattr__ pattern: it raises AttributeError for unknown names and caches resolved names in globals(). It sits in the generated OpenAI SDK package and does no decoding, dynamic execution, or network access.
info ~~warn~~ → info by review dynamic-attribute openai/resources/vector_stores/__init__.py:68:9

reach-by-name through `globals` (ast pass, confidence 0.60)
```
            raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
        globals()[name] = value
        return value
```
likely benign LLM, confidence 0.93 Lazy module attribute loader in the OpenAI SDK's vector_stores package that caches resolved names into globals().
Reasoning
The snippet is the standard PEP 562 lazy-import __getattr__ pattern: it raises AttributeError for unknown names and caches resolved names in globals(). It sits in the generated OpenAI SDK package and does no decoding, dynamic execution, or network access.

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 openai-3.36.1-py3-none-any.whl https://files.pythonhosted.org/packages/be/e4/83f139714d10d75af2b6891a20c973945dd9b942b11cc407ba4536fb40b9/openai-3.36.1-py3-none-any.whl
printf '%s  %s\n' 4c15b6765fe1792c5ad753556f44c7f82c2920c5e9e40219c0fca97369e923d3 openai-3.36.1-py3-none-any.whl | shasum -a 256 -c -
unzip -q openai-3.36.1-py3-none-any.whl -d pkg
disclude scan --untrusted --severity info pkg