Ordered by severity, then signals introduced in this release. Hidden characters are shown as ⟨U+…⟩.
-
line length 862 characters (raw pass, confidence 0.50)
vocab += [("ar_AR", 0.0), ("cs_CZ", 0.0), ("de_DE", 0.0), ("en_XX", 0.0), ("es_XX", 0.0), ("et_EE", 0.0), ("fi_FI", 0.0), ("fr_XX", 0.0), ("gu_IN", 0.0), ("hi_IN", 0.0), ("it_IT", 0.0), ("ja_XX", 0.0), ("kk_KZ", 0.0), ("ko_KR", 0.0), ("lt_LT", 0.0), ("lv_LV", 0.0), ("my_MM", 0.0), ("ne_NP", 0.0), ("nl_XX", 0.0)
-
file mixes tab and space indentation (2 tab-indented and 3906 space-indented lines) (raw pass, confidence 0.40)
from ..cache_utils import (
Cache,
DynamicCache,
EncoderDecoderCache,
-
reach-by-name through `vars.get` (ast pass, confidence 0.60)
cfg, args = args_file_parser.parse_known_args(args=args)
cmd_args_file_paths = vars(cfg).get(args_file_flag.lstrip("-"), None)
if cmd_args_file_paths:
likely benign
LLM, confidence 0.90
Reads an argparse namespace attribute by name to find args-file paths.
Reasoning
vars(cfg).get(name) reads a parsed argparse namespace attribute by name; this is ordinary dataclass/argparse handling of args-file flags, not hidden execution.
-
file imports decoder module(s) base64 and calls `.decompress()` — embedded payload decompressed at runtime (ast pass, confidence 0.75)
try:
b64 = base64.decodebytes(image.encode())
image = PIL.Image.open(BytesIO(b64))
except Exception as e:
likely benign
LLM, confidence 0.90
Base64-decodes an image string and opens it with PIL.
Reasoning
base64 decoding of an image string passed by the user is a standard data-URL/image loading path; the decoded bytes are opened as an image with PIL, not executed.
-
reach-by-name through `globals` (ast pass, confidence 0.60)
originals[module][func_name] = getattr(module, func_name)
setattr(module, func_name, globals()[func_name])
yield
finally:
likely benign
LLM, confidence 0.85
Temporarily swaps module init functions with same-module globals inside a context manager.
Reasoning
globals()[func_name] looks up a function defined in the same module for a context manager that temporarily patches torch init functions and restores originals in finally; it is a bounded, internal lookup.
-
identifier `Σ_h` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)
The scoring logic computes:
index_score[b,s,t] = Σ_h (weight[b,s,h] · softmax_scale · q[b,s,h,:] · k[b,t,:])
Args:
-
identifier `Σ_h` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)
The scoring logic computes:
index_score[b,s,t] = Σ_h (weight[b,s,h] · softmax_scale · q[b,s,h,:] · k[b,t,:])
Args:
-
identifier `Σ_h` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)
The scoring logic computes:
index_score[b,s,t] = Σ_h (weight[b,s,h] · softmax_scale · q[b,s,h,:] · k[b,t,:])
Args:
-
identifier `θ_i` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)
Gemma3's per-layer-type buffers), specialised for V4's *interleaved* RoPE.
Interleaved RoPE: one `θ_i` per pair (`rope_head_dim // 2` entries),
DIFF no end-to-end duplication. Same shape as `inv_freq @ position_ids`.
-
identifier `θ_i` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)
Gemma3's per-layer-type buffers), specialised for V4's *interleaved* RoPE.
Interleaved RoPE: one `θ_i` per pair (`rope_head_dim // 2` entries),
DIFF no end-to-end duplication. Same shape as `inv_freq @ position_ids`.
-
identifier `K1ᵀ` mixes scripts: Latin + Other (in string/comment) (raw pass, confidence 0.40)
Computes ``(softmax(Q1 K1ᵀ) - λ · softmax(Q2 K2ᵀ)) · V`` as two standard attention calls
sharing Q and K over the two halves of V. The two-call structure is ~30% faster than the
V-doubling shortcut at production shapes, since asymmetric V (``head_dim_v != head_dim_q``)
-
identifier `K2ᵀ` mixes scripts: Latin + Other (in string/comment) (raw pass, confidence 0.40)
Computes ``(softmax(Q1 K1ᵀ) - λ · softmax(Q2 K2ᵀ)) · V`` as two standard attention calls
sharing Q and K over the two halves of V. The two-call structure is ~30% faster than the
V-doubling shortcut at production shapes, since asymmetric V (``head_dim_v != head_dim_q``)
-
identifier `K1ᵀ` mixes scripts: Latin + Other (in string/comment) (raw pass, confidence 0.40)
Computes ``(softmax(Q1 K1ᵀ) - λ · softmax(Q2 K2ᵀ)) · V`` as two standard attention calls
sharing Q and K over the two halves of V. The two-call structure is ~30% faster than the
V-doubling shortcut at production shapes, since asymmetric V (``head_dim_v != head_dim_q``)
-
identifier `K2ᵀ` mixes scripts: Latin + Other (in string/comment) (raw pass, confidence 0.40)
Computes ``(softmax(Q1 K1ᵀ) - λ · softmax(Q2 K2ᵀ)) · V`` as two standard attention calls
sharing Q and K over the two halves of V. The two-call structure is ~30% faster than the
V-doubling shortcut at production shapes, since asymmetric V (``head_dim_v != head_dim_q``)
-
identifier `Cβ` mixes scripts: Latin + Greek (in string/comment) (raw pass, confidence 0.40)
distogram_atom_idx (`torch.Tensor` of shape `(batch_size, num_tokens)`):
Index of the representative atom (Cβ, or Cα for glycine) of each token. Used by the
confidence head; the trunk does not need it.
num_diffusion_samples (`int`, *optional*):
-
identifier `Cα` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)
distogram_atom_idx (`torch.Tensor` of shape `(batch_size, num_tokens)`):
Index of the representative atom (Cβ, or Cα for glycine) of each token. Used by the
confidence head; the trunk does not need it.
num_diffusion_samples (`int`, *optional*):
-
identifier `Cα` mixes scripts: Latin + Greek (in string/comment) (raw pass, confidence 0.40)
distogram_atom_idx (`torch.Tensor` of shape `(batch_size, num_tokens)`):
Index of the representative atom (Cβ, or Cα for glycine) of each token. Used by the
confidence head; the trunk does not need it.
num_diffusion_samples (`int`, *optional*):
-
identifier `Cα` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)
plddt_ca (`torch.FloatTensor` of shape `(num_diffusion_samples, num_tokens)`):
Predicted lDDT at the representative (Cα) atom of each token.
complex_plddt (`torch.FloatTensor` of shape `(num_diffusion_samples,)`):
Mean pLDDT over all atoms of the complex.
-
identifier `Cα` mixes scripts: Latin + Greek (in string/comment) (raw pass, confidence 0.40)
plddt_ca (`torch.FloatTensor` of shape `(num_diffusion_samples, num_tokens)`):
Predicted lDDT at the representative (Cα) atom of each token.
complex_plddt (`torch.FloatTensor` of shape `(num_diffusion_samples,)`):
Mean pLDDT over all atoms of the complex.
-
identifier `Cα` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)
plddt_ca (`torch.FloatTensor` of shape `(num_diffusion_samples, num_tokens)`):
Predicted lDDT at the representative (Cα) atom of each token.
complex_plddt (`torch.FloatTensor` of shape `(num_diffusion_samples,)`):
Mean pLDDT over all atoms of the complex.
-
identifier `Cα` mixes scripts: Latin + Greek (in string/comment) (raw pass, confidence 0.40)
plddt_ca (`torch.FloatTensor` of shape `(num_diffusion_samples, num_tokens)`):
Predicted lDDT at the representative (Cα) atom of each token.
complex_plddt (`torch.FloatTensor` of shape `(num_diffusion_samples,)`):
Mean pLDDT over all atoms of the complex.
-
identifier `Σ_h` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)
The scoring logic computes:
index_score[b,s,t] = Σ_h (weight[b,s,h] · softmax_scale · q[b,s,h,:] · k[b,t,:])
Args:
-
line length 520 characters (raw pass, confidence 0.50)
image_grid_pinpoints = [[384, 384], [384, 768], [384, 1152], [384, 1536], [384, 1920], [384, 2304], [768, 384], [768, 768], [768, 1152], [768, 1536], [768, 1920], [768, 2304], [1152, 384], [1152, 768], [1152, 1152], [1152, 1536], [1152, 1920], [1152, 2304], [1536, 384], [1536, 768], [1536, 1152], [1536, 1536], [153
-
line length 520 characters (raw pass, confidence 0.50)
image_grid_pinpoints = [[384, 384], [384, 768], [384, 1152], [384, 1536], [384, 1920], [384, 2304], [768, 384], [768, 768], [768, 1152], [768, 1536], [768, 1920], [768, 2304], [1152, 384], [1152, 768], [1152, 1152], [1152, 1536], [1152, 1920], [1152, 2304], [1536, 384], [1536, 768], [1536, 1152], [1536, 1536], [153
-
line length 520 characters (raw pass, confidence 0.50)
image_grid_pinpoints = [[384, 384], [384, 768], [384, 1152], [384, 1536], [384, 1920], [384, 2304], [768, 384], [768, 768], [768, 1152], [768, 1536], [768, 1920], [768, 2304], [1152, 384], [1152, 768], [1152, 1152], [1152, 1536], [1152, 1920], [1152, 2304], [1536, 384], [1536, 768], [1536, 1152], [1536, 1536], [153
-
line length 520 characters (raw pass, confidence 0.50)
image_grid_pinpoints = [[384, 384], [384, 768], [384, 1152], [384, 1536], [384, 1920], [384, 2304], [768, 384], [768, 768], [768, 1152], [768, 1536], [768, 1920], [768, 2304], [1152, 384], [1152, 768], [1152, 1152], [1152, 1536], [1152, 1920], [1152, 2304], [1536, 384], [1536, 768], [1536, 1152], [1536, 1536], [153
-
line length 618 characters (raw pass, confidence 0.50)
"m2m100": ["af", "am", "ar", "ast", "az", "ba", "be", "bg", "bn", "br", "bs", "ca", "ceb", "cs", "cy", "da", "de", "el", "en", "es", "et", "fa", "ff", "fi", "fr", "fy", "ga", "gd", "gl", "gu", "ha", "he", "hi", "hr", "ht", "hu", "hy", "id", "ig", "ilo", "is", "it", "ja", "jv", "ka", "kk", "km", "kn", "ko", "lb", "l
-
line length 506 characters (raw pass, confidence 0.50)
FAIRSEQ_LANGUAGE_CODES = ["ar_AR", "cs_CZ", "de_DE", "en_XX", "es_XX", "et_EE", "fi_FI", "fr_XX", "gu_IN", "hi_IN", "it_IT", "ja_XX", "kk_KZ", "ko_KR", "lt_LT", "lv_LV", "my_MM", "ne_NP", "nl_XX", "ro_RO", "ru_RU", "si_LK", "tr_TR", "vi_VN", "zh_CN", "af_ZA", "az_AZ", "bn_IN", "fa_IR", "he_IL", "hr_HR", "id_ID", "ka_GE
-
identifier `βkk` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)
last_recurrent_state = last_recurrent_state * chunk_decay[:, :, i] + key[:, :, i].transpose(-1, -2) @ v_new
-
identifier `βvk` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)
last_recurrent_state = last_recurrent_state * chunk_decay[:, :, i] + key[:, :, i].transpose(-1, -2) @ v_new
-
base64-like blob (64 bytes, compression ratio 1.17) (in comment) (raw pass, confidence 0.36)
for idx, decoder_layer in enumerate(self.layers):
reference_points_input = reference_points.unsqueeze(2)
-
base64-like blob (64 bytes, compression ratio 1.17) (in comment) (raw pass, confidence 0.36)
num_backbone_outs = len(intermediate_channel_sizes)
encoder_input_proj_list = []
-
base64-like blob (64 bytes, compression ratio 1.17) (in comment) (raw pass, confidence 0.36)
num_backbone_outs = len(config.decoder_in_channels)
decoder_input_proj_list = []
-
base64-like blob (64 bytes, compression ratio 1.17) (in comment) (raw pass, confidence 0.36)
sources = []
for level, source in enumerate(encoder_outputs.last_hidden_state):
-
base64-like blob (64 bytes, compression ratio 1.17) (in comment) (raw pass, confidence 0.36)
num_backbone_outs = len(intermediate_channel_sizes)
-
base64-like blob (64 bytes, compression ratio 1.17) (in comment) (raw pass, confidence 0.36)
num_backbone_outs = len(config.decoder_in_channels)
decoder_input_proj_list = []
-
identifier `βkk` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)
last_recurrent_state = last_recurrent_state * chunk_decay[:, :, i] + key[:, :, i].transpose(-1, -2) @ v_new
-
identifier `βvk` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)
last_recurrent_state = last_recurrent_state * chunk_decay[:, :, i] + key[:, :, i].transpose(-1, -2) @ v_new
-
identifier `βkk` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)
last_recurrent_state = last_recurrent_state * chunk_decay[:, :, i] + key[:, :, i].transpose(-1, -2) @ v_new
-
identifier `βvk` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)
last_recurrent_state = last_recurrent_state * chunk_decay[:, :, i] + key[:, :, i].transpose(-1, -2) @ v_new
-
identifier `βkk` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)
last_recurrent_state = last_recurrent_state * chunk_decay[:, :, i] + key[:, :, i].transpose(-1, -2) @ v_new
-
identifier `βvk` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)
last_recurrent_state = last_recurrent_state * chunk_decay[:, :, i] + key[:, :, i].transpose(-1, -2) @ v_new
-
identifier `βkk` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)
last_recurrent_state = last_recurrent_state * chunk_decay[:, :, i] + key[:, :, i].transpose(-1, -2) @ v_new
-
identifier `βvk` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)
last_recurrent_state = last_recurrent_state * chunk_decay[:, :, i] + key[:, :, i].transpose(-1, -2) @ v_new
-
identifier `βkk` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)
last_recurrent_state = last_recurrent_state * chunk_decay[:, :, i] + key[:, :, i].transpose(-1, -2) @ v_new
-
identifier `βvk` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)
last_recurrent_state = last_recurrent_state * chunk_decay[:, :, i] + key[:, :, i].transpose(-1, -2) @ v_new
-
identifier `θd` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)
sin, cos = sinusoidal_pos.chunk(2, dim=-1)
sin_pos = torch.stack([sin, sin], dim=-1).reshape_as(sinusoidal_pos)
-
identifier `θd` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)
sin, cos = sinusoidal_pos.chunk(2, dim=-1)
sin_pos = torch.stack([sin, sin], dim=-1).reshape_as(sinusoidal_pos)
-
identifier `θd` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)
sin, cos = sinusoidal_pos.chunk(2, dim=-1)
sin_pos = torch.stack([sin, sin], dim=-1).reshape_as(sinusoidal_pos)
-
identifier `θd` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)
sin_pos = torch.stack([sin, sin], dim=-1).reshape_as(sinusoidal_pos)
cos_pos = torch.stack([cos, cos], dim=-1).reshape_as(sinusoidal_pos)
-
identifier `θd` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)
sin_pos = torch.stack([sin, sin], dim=-1).reshape_as(sinusoidal_pos)
cos_pos = torch.stack([cos, cos], dim=-1).reshape_as(sinusoidal_pos)
-
identifier `θd` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)
sin_pos = torch.stack([sin, sin], dim=-1).reshape_as(sinusoidal_pos)
cos_pos = torch.stack([cos, cos], dim=-1).reshape_as(sinusoidal_pos)
-
`__import__` called on a non-literal expression (ast pass, confidence 0.70)
module_name, attr_name = self._MAPPING_NAMES[key]
module = __import__(module_name, fromlist=[attr_name])
return getattr(module, attr_name)
likely benign
LLM, confidence 0.80
Lazy-loads a class by importing a module name from an internal mapping.
Reasoning
Lazy import via a module name from a fixed class-level mapping (_MAPPING_NAMES) is a common lazy-loading pattern in transformers; the flagged non-literal is internal, though the finding is critical severity and the source of key is not shown.
-
`inspect.stack` — call-stack frame introspection (ast pass, confidence 0.70)
caller__file__ = inspect.stack()[1][1]
tests_dir = os.path.abspath(os.path.dirname(caller__file__))
likely benign
LLM, confidence 0.90
Uses the caller's frame to find the test directory.
Reasoning
inspect.stack()[1] is used to locate the calling test file's directory, a standard testing helper pattern with no malicious effect.
-
`inspect.stack` — call-stack frame introspection (ast pass, confidence 0.70)
stack_from_inspect = inspect.stack()
likely benign
LLM, confidence 0.90
Walks the call stack in a testing utility.
Reasoning
inspect.stack() is used to walk call frames for test reporting or debugging; no sensitive or networked action is involved.
-
reach-by-name through `vars` (ast pass, confidence 0.60)
if key in vars(cls):
return vars(cls)[key]
raise AttributeError(f"{self.__class__.__name__} has no attribute {key}")
return object.__getattribute__(self, key)
likely benign
LLM, confidence 0.85
Implements a __getattr__ fallback that looks up class attributes by name.
Reasoning
vars(cls)[key] and object.__getattribute__ implement attribute fallback lookup on the class, a normal Python attribute-resolution pattern for tokenizer attributes.
-
`inspect.currentframe` — call-stack frame introspection (ast pass, confidence 0.70)
caller = inspect.currentframe().f_back.f_back.f_code.co_name
if caller in self.stages:
return self.stages[caller]
likely benign
LLM, confidence 0.90
Derives a stage name from the calling function's name.
Reasoning
currentframe().f_back used to derive a stage name from the caller's function name; benign introspection for logging or stage naming.
-
concatenated bytes literal contains 566 `\xNN` escapes (56% of content) — binary payload shape (ast pass, confidence 0.85)
serialized_pb=(
b'\n\x19sentencepiece_model.proto\x12\rsentencepiece"\xa1\n\n\x0bTrainerSpec\x12\r\n\x05input\x18\x01'
b" \x03(\t\x12\x14\n\x0cinput_format\x18\x07 \x01(\t\x12\x14\n\x0cmodel_prefix\x18\x02"
b" \x01(\t\x12\x41\n\nmodel_type\x18\x03"
likely benign
LLM, confidence 0.90
Generated protobuf serialized descriptor bytes for the SentencePiece model schema.
Reasoning
This is a generated protobuf descriptor for sentencepiece_model.proto; the bytes are serialized schema data, and the escape density is typical of protoc output.
-
bytes literal contains 44 `\xNN` escapes (71% of content) — binary payload shape (ast pass, confidence 0.85)
b" \x12+\n\x1ctrain_extremely_large_corpus\x18\x31"
b' \x01(\x08:\x05\x66\x61lse"5\n\tModelType\x12\x0b\n\x07UNIGRAM\x10\x01\x12\x07\n\x03\x42PE\x10\x02\x12\x08\n\x04WORD\x10\x03\x12\x08\n\x04\x43HAR\x10\x04*\t\x08\xc8\x01\x10\x80\x80\x80\x80\x02"\xd1\x01\n\x0eNormalizerSpec\x12\x0c\n\x04name\x18\x01'
likely benign
LLM, confidence 0.90
Generated protobuf serialized descriptor bytes for SentencePiece enums and fields.
Reasoning
Generated protobuf descriptor data with schema field names and enum values; the byte shape is expected for protoc output and is not executed as code.
-
bytes literal contains 56 `\xNN` escapes (64% of content) — binary payload shape (ast pass, confidence 0.85)
b' \x01(\x0e\x32,.sentencepiece.ModelProto.SentencePiece.Type:\x06NORMAL"T\n\x04Type\x12\n\n\x06NORMAL\x10\x01\x12\x0b\n\x07UNKNOWN\x10\x02\x12\x0b\n\x07\x43ONTROL\x10\x03\x12\x10\n\x0cUSER_DEFINED\x10\x04\x12\x08\n\x04\x42YTE\x10\x06\x12\n\n\x06UNUSED\x10\x05*\t\x08\xc8\x01\x10\x80\x80\x80\x80\x02*\t\x08\xc8\x
likely benign
LLM, confidence 0.90
Generated protobuf serialized descriptor bytes for SentencePiece types.
Reasoning
Same generated protobuf descriptor pattern; the escapes encode schema text and enum definitions, consistent with a standard _pb2 file.
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.
disclude.io