Local UI to run and train LLMs and diffusion models. Supports GGUF, MLX, Qwen3.8, DeepSeek-V4.1, MiniMax-H3, Gemma 4, FLUX and more.
Python agentaichatgptdeepseekfine-tuninggemmaimage-generationllamallmllmsopenaipythonqwenreinforcement-learningself-hostedstable-diffusiontext-to-speechttsuiunsloth
# SPDX-License-Identifier: AGPL-3.0-only
# Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
"""Compares frontend guard conditions, not exact text, so rewraps and renames do not break tests."""
import itertools
import re
def blank_literals_and_comments(source: str) -> str:
"""Blanks comments and string contents in one pass, keeping length so offsets still line up."""
out, i, n = [], 0, len(source)
while i < n:
char, nxt = source[i], source[i + 1 : i + 2]
if char == "/" and nxt == "/":
while i < n and source[i] != "\n":
out.append(" ")
i += 1
continue
if char == "/" and nxt == "*":
while i < n and not (source[i] == "*" and source[i + 1 : i + 2] == "/"):
out.append("\n" if source[i] == "\n" else " ")
i += 1
out.append(" ")
i += 2
continue
if char in "\"'`":
out.append(char)
i += 1
while i < n:
if source[i] == "\\":
out.append(" ")
i += 2
continue
if source[i] == char:
out.append(char)
i += 1
break
out.append("\n" if source[i] == "\n" else " ")
i += 1
continue
out.append(char)
i += 1
return "".join(out)
def parenthesised_bodies(source: str, keyword: str):
"""Each `keyword (...)` body in `source`, whitespace collapsed, parentheses balanced."""
source = blank_literals_and_comments(source)
for match in re.finditer(rf"\b{re.escape(keyword)}\s*\(", source):
depth, i = 0, match.end() - 1
while i < len(source):
char = source[i]
if char == "(":
depth += 1
elif char == ")":
depth -= 1
if depth == 0:
yield re.sub(r"\s+", " ", source[match.end() : i]).strip()
break
i += 1
def depth_zero_split(text: str, operator: str) -> list[str]:
"""`text` cut at every `operator` sitting outside parentheses. No unwrapping."""
parts, depth, current, i = [], 0, "", 0
while i < len(text):
char = text[i]
if char == "(":
depth += 1
elif char == ")":
depth -= 1
elif depth == 0 and text[i : i + len(operator)] == operator:
parts.append(current)
current = ""
i += len(operator)
continue
current += char
i += 1
parts.append(current)
return parts
def balanced(text: str) -> bool:
"""True when every parenthesis in `text` closes within it."""
depth = 0
for char in text:
depth += (char == "(") - (char == ")")
if depth < 0:
return False
return depth == 0
def split_operands(text: str, operator: str) -> list[str]:
"""Splits at depth zero and unwraps redundant parens, recursing only when a split makes progress."""
operands = []
for part in depth_zero_split(text, operator):
part = part.strip()
while part.startswith("(") and part.endswith(")") and balanced(part[1:-1]):
part = part[1:-1].strip()
inner = depth_zero_split(part, operator)
operands.extend(
[piece for sub in inner for piece in split_operands(sub, operator)]
if len(inner) > 1
else [part]
)
return [part for part in operands if part]
def assert_guard_holds(
source: str, keyword: str, operator: str, required: set[str], *, expected: int
) -> None:
"""Counts exactly the complete guards, not the first match, and splits only on the given operator."""
complete = [
body
for body in parenthesised_bodies(source, keyword)
if required <= set(split_operands(body, operator))
]
assert len(complete) == expected, (
f"expected {expected} {keyword} guards joining {sorted(required)} with {operator!r}, "
f"found {len(complete)}: {complete}"
)
# A line ending in one of these continues onto the next (Prettier breaks `a &&\n b` there).
_CONTINUES = ("&&", "||", "??", "?", ":", ",", "+", "-", "*", "/", "=", "(", "[", "{", ".")
def _declaration_bodies(source: str):
"""Ends each const at a depth-zero semicolon or a balanced line end, since semicolons are rare."""
blanked = blank_literals_and_comments(source)
for match in re.finditer(r"\bconst (\w+)\s*=(?!=)", blanked):
i, depth, n = match.end(), 0, len(blanked)
while i < n:
char = blanked[i]
if char in "([{":
depth += 1
elif char in ")]}":
if depth == 0:
break
depth -= 1
elif depth == 0 and char == ";":
break
elif depth == 0 and char == "\n":
so_far = blanked[match.end() : i].rstrip()
if so_far and not so_far.endswith(_CONTINUES):
break
i += 1
yield match.group(1), source[match.end() : i]
def binding_joining(source: str, operator: str, required: set[str]) -> str | None:
"""Name of the first `const NAME = ...` whose operands cover `required`, else None."""
for name, body in _declaration_bodies(source):
if required <= set(split_operands(re.sub(r"\s+", " ", body), operator)):
return name
return None
def expand_bindings(
source: str,
expression: str,
*,
stop = (),
limit: int = 8,
) -> str:
"""Inlines local consts down to the stop names, so behaviour is compared, not how it is spelled."""
bodies = {
name: re.sub(r"\s+", " ", body).strip()
for name, body in _declaration_bodies(source)
if name not in stop
}
for _ in range(limit):
grown = re.sub(
r"\b\w+\b",
lambda match: f"({bodies[match.group(0)]})"
if match.group(0) in bodies
else match.group(0),
expression,
)
if grown == expression:
return expression
expression = grown
raise AssertionError(f"{expression!r} never stopped expanding; a binding cycle?")
def boolean_table(expression: str, names) -> dict:
"""Truth table of a boolean-only JS expression; other operators raise rather than mistranslate."""
python = re.sub(r"\bundefined\b", "False", expression)
python = python.replace("&&", " and ").replace("||", " or ").replace("!", " not ")
leftover = re.sub(r"\b(?:and|or|not|False)\b|[()\s]|\b[A-Za-z_]\w*\b", "", python)
assert not leftover, f"{expression!r} is not a plain boolean expression: {leftover!r} left"
reads = set(re.findall(r"\b[A-Za-z_]\w*\b", python)) - {"and", "or", "not", "False"}
assert reads <= set(
names
), f"{expression!r} reads names this contract does not cover: {sorted(reads - set(names))}"
table = {}
for combination in itertools.product((False, True), repeat = len(names)):
table[combination] = bool(
eval(python, {"__builtins__": {}}, dict(zip(names, combination))) # noqa: S307
)
return table
def attribute_expressions(source: str, attribute: str) -> list[str]:
"""Finds attribute={...} expressions in blanked source, so comments and strings cannot match."""
blanked = blank_literals_and_comments(source)
found = []
for match in re.finditer(rf"(?<![\w-]){re.escape(attribute)}\s*=\s*{{", blanked):
depth, i = 0, match.end() - 1
while i < len(blanked):
char = blanked[i]
if char == "{":
depth += 1
elif char == "}":
depth -= 1
if depth == 0:
found.append(re.sub(r"\s+", " ", source[match.end() : i]).strip())
break
i += 1
return found
def gates_the_markup(source: str, name: str) -> bool:
"""Only && or a ternary's true arm counts as gating; a null true arm inverts it, mounting on false."""
if re.search(rf"{{\s*{re.escape(name)}\s*&&", source):
return True
arm = re.search(rf"{{\s*{re.escape(name)}\s*\?(.*)", source, re.S)
return bool(arm) and not re.match(r"\s*(null|undefined|false)\b", arm.group(1))