logit-classifier 0.2.1__tar.gz → 0.4.0__tar.gz

{logit_classifier-0.2.1 → logit_classifier-0.4.0}/FINDINGS.md

@@ -295,6 +295,31 @@ dispatcher reaches the math backend, which builds the full attention matrix. Mea
 `HFBackend` probes the backends at startup, at the model's own dtype, and pins the working
 ones. `benchmark.py`.
 
+## One presence wording, two threshold pairs
+
+Correct tags per tile at a pooled precision, over 905 judged tile candidates on 23 tiles,
+from the Logit Tagger's `tests-AB/ab_presence_wording.py` (round 4).
+
+| Wording | P 0.95 | P 0.97 | P 0.98 | P 0.99 |
+|---|---|---|---|---|
+| "This image visibly contains {TAG}" | 17.43 | 12.78 | 9.87 | 6.04 |
+| "Is there a {TAG} in this image?" (0.3.0, article by rule) | 17.35 | 11.30 | 2.39 | 2.09 |
+| "Present in this image: {TAG}" | 17.61 | 8.74 | 8.13 | 6.74 |
+
+The shipped fp8 tile pass cut offline, per tile and prompt over 69 runs, from
+ContextAnchoredTileRefine's `tests-AB/ab_tags_paired.py`.
+
+| Thresholds | Correct | Wrong or vague | Precision |
+|---|---|---|---|
+| broad (0.999, 0.9999) | 12.32 | 0.54 | 0.958 |
+| strict (0.99998, 0.99998) | 7.33 | 0.17 | 0.977 |
+
+Every paired interval against "This image visibly contains {TAG}" at 0.95 and 0.98 spans zero.
+It needs no grammar, and the tile pass already asked it, so its thresholds carry over. On
+declared COCO tag lists "Is there a {TAG} in this image?" (0.3.0, article by rule) kept more
+correct tags at precision 0.98 (3.79 against 1.90 per image), which is the cost of one
+wording.
+
 ## Bugs found and fixed
 
 | Bug | Effect | Fix |
@@ -329,6 +354,6 @@ and 23.66 GB against 15.12 GB, because a cropped cache is a non-contiguous view.
 
 ## Layout
 
-`tests/` holds the pytest suite, 146 unit tests and 14 that need the GPU. `tests-AB/` holds
+`tests/` holds the pytest suite, the unit tests and 14 tests that need the GPU. `tests-AB/` holds
 the measurement harnesses, matching ComfyUI-ContextAnchoredTileRefine. Fixtures live in
 `tests/fixtures/` and `tests-AB/ab_env.py` points at them.

{logit_classifier-0.2.1 → logit_classifier-0.4.0}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.5
 Name: logit-classifier
-Version: 0.2.1
-Summary: Local zero-shot classifier for text and images. Declares options, returns a calibrated probability for each, generates no text. Accepts the TypeSafe System One request format.
+Version: 0.4.0
+Summary: Local zero-shot classifier for text and images. Declares options and reads a calibrated probability for each from the logits. Accepts the TypeSafe System One request format, and ships a toolkit of image tag tools and ComfyUI node tools.
 Project-URL: Repository, https://github.com/Blakeem/logit-classifier
 Project-URL: Bug Tracker, https://github.com/Blakeem/logit-classifier/issues
 Author: Blake
@@ -124,6 +124,14 @@ print(response.to_dict())
 `load_model` loads the weights through the `hf` extra and returns a `Backend`.
 `Classifier(Config())` calls it for you when you pass no backend.
 
+`classifier.nouls` asks a list of statements about one state and returns one probability
+per statement. It sends more than 256 statements as several requests.
+
+```python
+probabilities = classifier.nouls(["The message is urgent", "The message is polite"],
+                                 state="the payment failed again")
+```
+
 Loading each model yourself is what lets one script compare several. The fitted
 temperature follows the backend, so every model is scored with its own value.
 
@@ -170,7 +178,7 @@ the model.
 
 ```json
 {
-  "model": "logit-classifier-0.2.1",
+  "model": "logit-classifier-0.4.0",
   "answers": {
     "department": {
       "type": "choice",
@@ -342,6 +350,82 @@ shape `[1, H, W, 3]`. An empty state asks about the image alone. Questions share
 pass of up to 4,096 tokens, and the image counts toward that limit. Any text encoder other
 than Qwen3-VL raises `UnsupportedModelError`.
 
+## Toolkit
+
+`logit_classifier.toolkit` holds tools built on the classifier with the settings our
+measurements found best. A project imports them to get good results without working out the
+wording, thresholds and host details itself. The toolkit uses the classifier's public API,
+and the classifier never imports the toolkit.
+
+| Package | Runs in | Holds |
+|---|---|---|
+| `logit_classifier.toolkit.tags` | any Python process | text tools for image tags and prompts |
+| `logit_classifier.toolkit.comfyui` | a ComfyUI node | a classifier over the workflow's CLIP, text generation, a progress display and an image tagger |
+
+### Tag Text Tools
+
+| Tool | Does |
+|---|---|
+| `parse_candidates` | splits a model's tag reply into clean tags with no duplicates |
+| `split_prompt` | splits an image prompt into its fragments |
+| `drop_subsets` | drops a tag whose words all appear in a longer tag |
+| `prompt_word_forms`, `in_prompt` | test whether a tag's words appear in a prompt, singular or plural |
+| `merge_candidates` | merges proposed tags with a prompt's tags under a cap |
+| `presence_statement` | writes "This image visibly contains car" with the tag as given |
+| `BROAD_THRESHOLDS`, `STRICT_THRESHOLDS` | the scores a tag must reach, broad for more tags and strict for fewer wrong ones |
+
+```python
+from logit_classifier.toolkit.tags import drop_subsets, parse_candidates
+
+tags = drop_subsets(parse_candidates("red car, car, wooden bench, bench"))
+# ['red car', 'wooden bench']
+```
+
+`drop_subsets(tags, rule="head-noun")` drops a tag only into a longer tag with the same head
+noun. The head noun is the last word before "of", "in", "on", "with" or "reading". So "cat"
+stays beside "cat ear", and "signage" is dropped beside "signage in chinese".
+
+### ComfyUI Tools
+
+These run inside a ComfyUI node over the CLIP the workflow loaded. Each one imports comfy and
+torch only when it is called. `logit_classifier.toolkit.comfyui` exports every tool. The table
+names the module of each tool it lists.
+
+| Module | Tool | Does |
+|---|---|---|
+| `classifier` | `comfy_classifier` | builds a classifier over the CLIP, with errors that name the node and the Load CLIP fix |
+| `generate` | `generate_text` | generates one greedy reply with the Qwen chat template, and stops early on a condition |
+| `generate` | `clip_generate` | runs core's generate, then clears the CUDA graphs it captured |
+| `scopes` | `shared_vision_encode` | runs the vision tower once per image for every generate and classify inside the block |
+| `scopes` | `skip_resident_loads` | skips core's model load while the CLIP is already on the GPU |
+| `progress` | `routed_progress_bars`, `send_status`, `run_outcome` | show one progress bar per run and a status line under the node |
+| `tagger` | `fit_image` | downscales an image to a pixel cap |
+| `tagger` | `tag_prompt` | lists the physical things a prompt names |
+| `tagger` | `tag_image` | tags an image, with a prompt's things added as candidates |
+| `tagger` | `TagSettings` | holds every wording, budget, cap and threshold of the tagger |
+
+The tagger generates candidate tags over the CLIP and verifies each one with the classifier.
+
+```python
+from logit_classifier.toolkit.comfyui import TagSettings, comfy_classifier, fit_image, tag_image
+
+classifier = comfy_classifier(clip, node="My Tagger")
+trace = tag_image(clip, classifier, fit_image(image, 1024 * 1024), settings=TagSettings(), thing_cache={})
+tags = trace.kept
+```
+
+`thing_cache` holds the thing check's answers across a run, so each tag is asked once. The
+`TagSettings` defaults are the current measured values, and a later release may change them.
+Pass every value your output depends on to keep it fixed.
+
+For fewer wrong tags, pass `STRICT_THRESHOLDS` as `verify_thresholds`.
+
+```python
+from logit_classifier.toolkit.tags import STRICT_THRESHOLDS
+
+settings = TagSettings(verify_thresholds=STRICT_THRESHOLDS)
+```
+
 ## Differences From Jev
 
 This project matches the System One request and response format and the documented limits.
@@ -360,13 +444,13 @@ Jev publishes status codes but no error body. The error shape here is our own.
 
 ```
 uv sync --all-extras
-uv run pytest tests/test_unit.py
-uv run pytest tests/test_model.py -m model
+uv run python -m pytest tests -m "not model"
+uv run python -m pytest tests/test_model.py -m model
 uv run ruff check .
 uv run mypy
 ```
 
-The unit tests need no weights. The model tests load the GPU and take about 15 seconds.
+The unit tests need no weights. The model tests load the GPU and take 24 to 126 seconds, the longer run being the first of a session.
 
 `FINDINGS.md` is the measurement record. Every number there names the script in
 `tests-AB/` that produced it.

{logit_classifier-0.2.1 → logit_classifier-0.4.0}/README.md

@@ -91,6 +91,14 @@ print(response.to_dict())
 `load_model` loads the weights through the `hf` extra and returns a `Backend`.
 `Classifier(Config())` calls it for you when you pass no backend.
 
+`classifier.nouls` asks a list of statements about one state and returns one probability
+per statement. It sends more than 256 statements as several requests.
+
+```python
+probabilities = classifier.nouls(["The message is urgent", "The message is polite"],
+                                 state="the payment failed again")
+```
+
 Loading each model yourself is what lets one script compare several. The fitted
 temperature follows the backend, so every model is scored with its own value.
 
@@ -137,7 +145,7 @@ the model.
 
 ```json
 {
-  "model": "logit-classifier-0.2.1",
+  "model": "logit-classifier-0.4.0",
   "answers": {
     "department": {
       "type": "choice",
@@ -309,6 +317,82 @@ shape `[1, H, W, 3]`. An empty state asks about the image alone. Questions share
 pass of up to 4,096 tokens, and the image counts toward that limit. Any text encoder other
 than Qwen3-VL raises `UnsupportedModelError`.
 
+## Toolkit
+
+`logit_classifier.toolkit` holds tools built on the classifier with the settings our
+measurements found best. A project imports them to get good results without working out the
+wording, thresholds and host details itself. The toolkit uses the classifier's public API,
+and the classifier never imports the toolkit.
+
+| Package | Runs in | Holds |
+|---|---|---|
+| `logit_classifier.toolkit.tags` | any Python process | text tools for image tags and prompts |
+| `logit_classifier.toolkit.comfyui` | a ComfyUI node | a classifier over the workflow's CLIP, text generation, a progress display and an image tagger |
+
+### Tag Text Tools
+
+| Tool | Does |
+|---|---|
+| `parse_candidates` | splits a model's tag reply into clean tags with no duplicates |
+| `split_prompt` | splits an image prompt into its fragments |
+| `drop_subsets` | drops a tag whose words all appear in a longer tag |
+| `prompt_word_forms`, `in_prompt` | test whether a tag's words appear in a prompt, singular or plural |
+| `merge_candidates` | merges proposed tags with a prompt's tags under a cap |
+| `presence_statement` | writes "This image visibly contains car" with the tag as given |
+| `BROAD_THRESHOLDS`, `STRICT_THRESHOLDS` | the scores a tag must reach, broad for more tags and strict for fewer wrong ones |
+
+```python
+from logit_classifier.toolkit.tags import drop_subsets, parse_candidates
+
+tags = drop_subsets(parse_candidates("red car, car, wooden bench, bench"))
+# ['red car', 'wooden bench']
+```
+
+`drop_subsets(tags, rule="head-noun")` drops a tag only into a longer tag with the same head
+noun. The head noun is the last word before "of", "in", "on", "with" or "reading". So "cat"
+stays beside "cat ear", and "signage" is dropped beside "signage in chinese".
+
+### ComfyUI Tools
+
+These run inside a ComfyUI node over the CLIP the workflow loaded. Each one imports comfy and
+torch only when it is called. `logit_classifier.toolkit.comfyui` exports every tool. The table
+names the module of each tool it lists.
+
+| Module | Tool | Does |
+|---|---|---|
+| `classifier` | `comfy_classifier` | builds a classifier over the CLIP, with errors that name the node and the Load CLIP fix |
+| `generate` | `generate_text` | generates one greedy reply with the Qwen chat template, and stops early on a condition |
+| `generate` | `clip_generate` | runs core's generate, then clears the CUDA graphs it captured |
+| `scopes` | `shared_vision_encode` | runs the vision tower once per image for every generate and classify inside the block |
+| `scopes` | `skip_resident_loads` | skips core's model load while the CLIP is already on the GPU |
+| `progress` | `routed_progress_bars`, `send_status`, `run_outcome` | show one progress bar per run and a status line under the node |
+| `tagger` | `fit_image` | downscales an image to a pixel cap |
+| `tagger` | `tag_prompt` | lists the physical things a prompt names |
+| `tagger` | `tag_image` | tags an image, with a prompt's things added as candidates |
+| `tagger` | `TagSettings` | holds every wording, budget, cap and threshold of the tagger |
+
+The tagger generates candidate tags over the CLIP and verifies each one with the classifier.
+
+```python
+from logit_classifier.toolkit.comfyui import TagSettings, comfy_classifier, fit_image, tag_image
+
+classifier = comfy_classifier(clip, node="My Tagger")
+trace = tag_image(clip, classifier, fit_image(image, 1024 * 1024), settings=TagSettings(), thing_cache={})
+tags = trace.kept
+```
+
+`thing_cache` holds the thing check's answers across a run, so each tag is asked once. The
+`TagSettings` defaults are the current measured values, and a later release may change them.
+Pass every value your output depends on to keep it fixed.
+
+For fewer wrong tags, pass `STRICT_THRESHOLDS` as `verify_thresholds`.
+
+```python
+from logit_classifier.toolkit.tags import STRICT_THRESHOLDS
+
+settings = TagSettings(verify_thresholds=STRICT_THRESHOLDS)
+```
+
 ## Differences From Jev
 
 This project matches the System One request and response format and the documented limits.
@@ -327,13 +411,13 @@ Jev publishes status codes but no error body. The error shape here is our own.
 
 ```
 uv sync --all-extras
-uv run pytest tests/test_unit.py
-uv run pytest tests/test_model.py -m model
+uv run python -m pytest tests -m "not model"
+uv run python -m pytest tests/test_model.py -m model
 uv run ruff check .
 uv run mypy
 ```
 
-The unit tests need no weights. The model tests load the GPU and take about 15 seconds.
+The unit tests need no weights. The model tests load the GPU and take 24 to 126 seconds, the longer run being the first of a session.
 
 `FINDINGS.md` is the measurement record. Every number there names the script in
 `tests-AB/` that produced it.

{logit_classifier-0.2.1 → logit_classifier-0.4.0}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "logit-classifier"
 dynamic = ["version"]
-description = "Local zero-shot classifier for text and images. Declares options, returns a calibrated probability for each, generates no text. Accepts the TypeSafe System One request format."
+description = "Local zero-shot classifier for text and images. Declares options and reads a calibrated probability for each from the logits. Accepts the TypeSafe System One request format, and ships a toolkit of image tag tools and ComfyUI node tools."
 requires-python = ">=3.12"
 license = "GPL-3.0-or-later"
 license-files = ["LICENSE"]
@@ -136,8 +136,8 @@ show_error_codes = true
 [[tool.mypy.overrides]]
 # transformers publishes no complete stubs, and accelerate none at all. torch is
 # listed so the type gate still runs where the hf extra is absent, such as CI.
-# The ComfyUI host supplies comfy, and neither this venv nor CI has it.
-module = ["transformers.*", "accelerate.*", "torch.*", "comfy.*"]
+# The ComfyUI host supplies comfy, server and comfy_execution, and neither this venv nor CI has them.
+module = ["transformers.*", "accelerate.*", "torch.*", "comfy.*", "server", "server.*", "comfy_execution.*"]
 ignore_missing_imports = true
 
 [[tool.mypy.overrides]]

{logit_classifier-0.2.1 → logit_classifier-0.4.0}/src/logit_classifier/_version.py

@@ -1,3 +1,3 @@
 """The package version, apart from __init__ so config.py can read it without a cycle."""
 
-__version__ = "0.2.1"
+__version__ = "0.4.0"

{logit_classifier-0.2.1 → logit_classifier-0.4.0}/src/logit_classifier/backends/comfy_clip.py

@@ -101,6 +101,29 @@ def _check_image(image: Any) -> None:
         raise ImageError(f"a ComfyUI IMAGE of shape [1, H, W, 3] is required, got shape {shape}")
 
 
+def _resident(clip: Any) -> bool:
+    """Whether the CLIP sits where its own load_model call leaves it, so loading again is a no-op.
+
+    Core's load_models_gpu has no fast path for a loaded model and costs about 0.1 s per call.
+    """
+    try:
+        import comfy.model_management as model_management
+
+        patcher = clip.patcher
+        loaded = model_management.current_loaded_models
+        # Another model's load always inserts at the head, and a changed LoRA patch set or an
+        # offloaded CLIP must reload.
+        return bool(
+            loaded
+            and loaded[0].model is patcher
+            and patcher.model.device == patcher.load_device
+            and patcher.model.current_weight_patches_uuid == patcher.patches_uuid
+            and patcher.model.model_loaded_weight_memory > 0
+        )
+    except (ImportError, AttributeError):
+        return False
+
+
 def _pack_passes(prefix_length: int, suffix_lengths: list[int], batch_branches: bool) -> list[list[int]]:
     """Group suffixes in request order into passes that stay under PACKED_TOKEN_CEILING.
 
@@ -284,7 +307,8 @@ class ComfyClipBackend:
             prefix_tokens[vision["pad_index"]] = {"type": "image", "data": vision["image"], "original_type": "image"}
         with _determinism(), torch.inference_mode():
             encoder.reset_clip_options()
-            clip.load_model({self._tokens_key: [prefix_tokens]})
+            if not _resident(clip):
+                clip.load_model({self._tokens_key: [prefix_tokens]})
             device = clip.patcher.load_device
             encoder.set_clip_options({"layer": None, "execution_device": device})
             # BaseGenerate.generate picks its execution dtype this way, at llama.py:1115-1120.

{logit_classifier-0.2.1 → logit_classifier-0.4.0}/src/logit_classifier/classifier.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import hashlib
 import random
+from collections.abc import Sequence
 from dataclasses import dataclass, field, replace
 from typing import Any
 
@@ -11,7 +12,7 @@ import numpy as np
 
 from .backends.base import Backend, BackendContractError, BranchLogits
 from .calibrate import PriorStore
-from .config import ANSWER_PREFILL, Config, fitted_temperature
+from .config import ANSWER_PREFILL, JEV_MAX_QUESTIONS, Config, fitted_temperature
 from .deps import MissingDependencyError
 from .prompt import (
     PROMPT_VERSION,
@@ -25,6 +26,7 @@ from .schema import (
     Answer,
     ChoiceAnswer,
     ChoiceQuestion,
+    JSONContent,
     NoulAnswer,
     NoulQuestion,
     Question,
@@ -279,6 +281,28 @@ class Classifier:
         )
         return response, diagnostics
 
+    def nouls(self, statements: Sequence[str], *, image: Any = None, state: JSONContent = "") -> list[float]:
+        """Return each statement's noul about the state, in statement order.
+
+        The statements are split into requests of JEV_MAX_QUESTIONS, one classify call each, and no
+        statements make no request. An empty state with an image is the image-only state.
+        """
+        keys = [f"s{index}" for index in range(len(statements))]
+        questions: dict[str, Question] = {}
+        nouls: list[float] = []
+
+        for start in range(0, len(statements), JEV_MAX_QUESTIONS):
+            window = slice(start, start + JEV_MAX_QUESTIONS)
+            questions = {key: NoulQuestion(instructions=statement)
+                         for key, statement in zip(keys[window], statements[window], strict=True)}
+            response, _diagnostics = self.classify(SystemOneRequest(state=state, questions=questions), image=image)
+            for key in questions:
+                answer = response.answers[key]
+                if not isinstance(answer, NoulAnswer):
+                    raise TypeError(f"question {key} got a {answer.type} answer, not a noul")
+                nouls.append(answer.noul)
+        return nouls
+
     def _round_answers(self, questions: dict[str, Question], branches: list[Branch],
                        probabilities: list[np.ndarray]) -> dict[str, Answer]:
         answers: dict[str, Answer] = {}

{logit_classifier-0.2.1 → logit_classifier-0.4.0}/src/logit_classifier/prompt.py

@@ -52,7 +52,7 @@ class Branch:
     suffix_text: str
 
 
-def _inert(text: str) -> str:
+def inert(text: str) -> str:
     # The backends' tokenizers read a <|...|> spelling in plain text as a control token, so
     # client text could otherwise forge a chat turn or a second image pad.
     return text.replace("<|", "<\u200b|")
@@ -67,7 +67,7 @@ def _option_lines(entries: list[tuple[str, str]]) -> str:
 
 
 def _question_block(prompt_line: str, entries: list[tuple[str, str]]) -> str:
-    return _inert(f"{prompt_line}\nOptions:\n{_option_lines(entries)}")
+    return inert(f"{prompt_line}\nOptions:\n{_option_lines(entries)}")
 
 
 def _choice_branches(qid: str, question: ChoiceQuestion, plan: BranchPlan,
@@ -152,7 +152,7 @@ def build_branches(questions: dict[str, Question], score_method: str = "joint",
 def prefix_content(state: Any, has_image: bool = False) -> str:
     """Build the user-message body every branch shares, image marker included."""
     marker = f"{IMAGE_MARKER}\n" if has_image else ""
-    return f"Context:\n{marker}{_inert(render_content(state))}\n\n"
+    return f"Context:\n{marker}{inert(render_content(state))}\n\n"
 
 
 def branch_content(state: Any, branch: Branch, has_image: bool = False) -> str:

logit_classifier-0.4.0/src/logit_classifier/tags.py

@@ -0,0 +1,36 @@
+"""The tag text tools, which moved to logit_classifier.toolkit.tags in 0.3.0.
+
+This path stays for code built on 0.2.x, which PyPI published. It raises no warning, so that code keeps a quiet log.
+"""
+
+from __future__ import annotations
+
+from .toolkit.tags import (
+    MAX_CANDIDATES,
+    MAX_REPEAT_BLOCK,
+    MAX_TAG_CHARS,
+    MAX_TAG_WORDS,
+    clean_item,
+    complete_tags,
+    drop_subsets,
+    drop_unfinished_tag,
+    normalize_item,
+    parse_candidates,
+    repeated_block,
+    split_prompt,
+)
+
+__all__ = [
+    "MAX_CANDIDATES",
+    "MAX_REPEAT_BLOCK",
+    "MAX_TAG_CHARS",
+    "MAX_TAG_WORDS",
+    "clean_item",
+    "complete_tags",
+    "drop_subsets",
+    "drop_unfinished_tag",
+    "normalize_item",
+    "parse_candidates",
+    "repeated_block",
+    "split_prompt",
+]

logit_classifier-0.4.0/src/logit_classifier/toolkit/__init__.py

@@ -0,0 +1,5 @@
+"""Tools built on the classifier core that follow its measured best practice.
+
+A caller gets good results from these tools without working the details out from the base API.
+The tools use the core and never mix into it, so the core never imports this package.
+"""

logit_classifier-0.4.0/src/logit_classifier/toolkit/comfyui/__init__.py

@@ -0,0 +1,50 @@
+"""The tools for a ComfyUI node that holds a loaded CLIP.
+
+Every module here imports comfy, server, torch and comfy_execution inside the functions that need them, so importing
+this package in a plain Python process loads none of them.
+"""
+
+from __future__ import annotations
+
+from ... import COMFY_SOCKET_TYPE
+from ...backends.comfy_clip import PACKED_TOKEN_CEILING, ComfyClipBackend
+from .classifier import comfy_classifier
+from .generate import IMAGE_SLOT, chat, clip_generate, generate_text, stop_when
+from .progress import routed_progress_bars, run_outcome, send_status, token_fill
+from .scopes import shared_vision_encode, skip_resident_loads
+from .tagger import (
+    ImageTagTrace,
+    PromptTagTrace,
+    TagSettings,
+    fit_image,
+    tag_image,
+    tag_prompt,
+    thing_scores,
+    to_english,
+)
+
+__all__ = [
+    "COMFY_SOCKET_TYPE",
+    "IMAGE_SLOT",
+    "PACKED_TOKEN_CEILING",
+    "ComfyClipBackend",
+    "ImageTagTrace",
+    "PromptTagTrace",
+    "TagSettings",
+    "chat",
+    "clip_generate",
+    "comfy_classifier",
+    "fit_image",
+    "generate_text",
+    "routed_progress_bars",
+    "run_outcome",
+    "send_status",
+    "shared_vision_encode",
+    "skip_resident_loads",
+    "stop_when",
+    "tag_image",
+    "tag_prompt",
+    "thing_scores",
+    "to_english",
+    "token_fill",
+]

logit_classifier-0.4.0/src/logit_classifier/toolkit/comfyui/classifier.py

@@ -0,0 +1,39 @@
+"""One Classifier over the CLIP a ComfyUI workflow already loaded."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from ...backends.base import UnsupportedModelError, VisionUnsupportedError
+from ...backends.comfy_clip import ComfyClipBackend
+from ...classifier import Classifier
+from ...config import Config
+
+
+def comfy_classifier(
+    clip: Any, *, node: str | None = None, needs_images: bool = True, batch_branches: bool = True
+) -> Classifier:
+    """One Classifier over the workflow's CLIP, with no running prior and no calibration file.
+
+    Each error starts with the node's name when one is given, and names the Load CLIP fix.
+    """
+    prefix = f"{node}: " if node else ""
+    backend: ComfyClipBackend | None = None
+
+    try:
+        backend = ComfyClipBackend(clip, batch_branches=batch_branches)
+    except UnsupportedModelError as error:
+        raise UnsupportedModelError(
+            f"{prefix}this CLIP is not a Qwen3-VL text encoder, so the node cannot read it. Load a Qwen3-VL text "
+            "encoder, such as qwen3vl_4b_fp8_scaled.safetensors, with a Load CLIP type that keeps its vision tower, "
+            "such as krea2."
+        ) from error
+    if needs_images and not backend.sees_images:
+        raise VisionUnsupportedError(
+            f"{prefix}this CLIP was loaded without its vision tower, so the node cannot read images. Load the "
+            "Qwen3-VL text encoder with a Load CLIP type that keeps it, such as krea2. The flux and flux2 types "
+            "drop it."
+        )
+    # A node reuses one classifier across a batch, and the running prior would make an item's answer depend on the
+    # items before it.
+    return Classifier(Config(use_prior_debias=False, calibration_path=None), backend)