diffusers-workflow 0.4.0__py3-none-any.whl

dw_mcp/models.py

@@ -0,0 +1,97 @@
+"""The model cache and the installed diffusers version.
+
+Where the rest of the surface spends the GPU, this one spends the disk and
+the network - and, for a delete, spends them in the direction that cannot be
+undone by waiting. Three tools here commit the machine to something a user
+would want to have been asked about first, so each carries its own gate and
+its own reason: a download is measured in tens of gigabytes, a delete throws
+away weights that have to be fetched again, and an update replaces the
+library every pipeline in the install is built on.
+
+The refusals deliberately do not share one message. A single "this costs
+something, confirm it" would be wrong for each of them in a different way,
+and a gate the user learns to wave through is not a gate.
+"""
+
+from dw_mcp.client import DwApiError, api_path
+
+DOWNLOAD_REFUSAL = (
+    "Downloading a model pulls tens of gigabytes over the network and into "
+    "the Hugging Face cache, and it keeps running in the background once "
+    "started. Tell the user which repo you are about to fetch and roughly "
+    "what it will cost them in disk and bandwidth, get their go-ahead, then "
+    "call again with acknowledged_cost=true. `list_models` shows what is "
+    "already cached - check there first, the model may not need fetching."
+)
+
+DELETE_REFUSAL = (
+    "Deleting a cached model removes every downloaded revision of it. "
+    "Nothing about this is recoverable locally: getting it back means "
+    "downloading it again. Tell the user exactly which repo you are about "
+    "to delete and how much it frees, get their go-ahead, then call again "
+    "with acknowledged_cost=true."
+)
+
+UPDATE_REFUSAL = (
+    "Updating diffusers replaces the installed library with GitHub HEAD - "
+    "an untagged development build that can break workflows which currently "
+    "run, and there is no undo through this tool. Tell the user what is "
+    "installed now (`get_diffusers_state`), why the update is worth it, and "
+    "get their go-ahead, then call again with acknowledged_cost=true."
+)
+
+
+def download_model(client, repo_id, acknowledged_cost=False):
+    """Start fetching a repo into the Hugging Face cache. Returns as soon as
+    the download is started - it does not wait for it to finish."""
+    if not acknowledged_cost:
+        raise DwApiError(DOWNLOAD_REFUSAL)
+    download = client.post_json("/api/models/download", {"repo_id": repo_id})
+    return {
+        **download,
+        "next": "Poll list_downloads for progress. The download continues in "
+        "the background; cancel_download stops it.",
+    }
+
+
+def list_downloads(client):
+    """Every download the server is running or has recently run."""
+    return client.get_json("/api/models/downloads")
+
+
+def cancel_download(client, download_id):
+    """Ask a running download to stop. Not gated: this ends a cost rather
+    than starting one, and partial files stay in the cache and resume on a
+    retry, so it is cheap to get wrong in the safe direction."""
+    return client.post_json(
+        api_path("api", "models", "downloads", download_id, "cancel")
+    )
+
+
+def delete_model(client, repo, acknowledged_cost=False):
+    """Delete every cached revision of one repo from the hub cache.
+
+    The server refuses this while a job or a download is active - it would
+    be pulling files out from under a reader - and that refusal carries the
+    reason, so it reaches the caller unflattened."""
+    if not acknowledged_cost:
+        raise DwApiError(DELETE_REFUSAL)
+    return client.delete_json("/api/models", params={"repo": repo})
+
+
+def get_diffusers_state(client):
+    """The installed diffusers version, its git commit when installed from
+    git, and the state of any update in flight."""
+    return client.get_json("/api/system/diffusers")
+
+
+def update_diffusers(client, acknowledged_cost=False):
+    """Upgrade diffusers to GitHub HEAD in the background."""
+    if not acknowledged_cost:
+        raise DwApiError(UPDATE_REFUSAL)
+    update = client.post_json("/api/system/diffusers/update")
+    return {
+        **update,
+        "next": "Poll get_diffusers_state for the outcome. The idle worker is "
+        "shut down on success so the next job imports the new version.",
+    }

dw_mcp/prompts.py

@@ -0,0 +1,104 @@
+"""The stored prompt library: the text a workflow reaches by `prompt:name`.
+
+Prompts are the other half of authoring. A workflow argument written as
+`"prompt:sitcom/duke"` resolves against this library at load time, so an
+agent that can write workflows but not prompts can only ever reference text
+somebody else stored.
+
+As in `authoring`, validation stays on the server. It already refuses a
+definition that fails the prompt schema and one whose `text` is itself a
+reference - re-checking either here would only give the two a chance to
+disagree.
+"""
+
+from dw_mcp.client import DwApiError, api_path, coerce_json_object
+
+ENHANCE_COST_REFUSAL = (
+    "Enhancing a prompt loads a language model and queues a real job on the "
+    "engine, which runs one job at a time - it delays any generation waiting "
+    "behind it. Tell the user what will be enhanced and with which preset, "
+    "get their go-ahead, then call again with acknowledged_cost=true."
+)
+
+
+def list_prompts(client, tag=None, intended_model=None, include_text=False):
+    """The library as a routing table: what each prompt is for, not what it
+    says.
+
+    The bodies are left out by default, which is the same lesson `list_jobs`
+    learned - the whole library is 44 prompts and 87 KB, past a client's
+    result cap, so a listing that carried them could not be called at all.
+    `get_prompt` is where a body comes from once one has been chosen.
+    """
+    params = {"include_text": "true" if include_text else "false"}
+    if tag is not None:
+        params["tag"] = tag
+    if intended_model is not None:
+        params["intended_model"] = intended_model
+    return client.get_json("/api/prompts", params=params)
+
+
+def get_prompt(client, name):
+    """One stored prompt's full definition, `name` being the same string a
+    workflow would reference it by."""
+    return client.get_json(api_path("api", "prompts", name))
+
+
+def get_prompt_schema(client):
+    """The JSON schema a stored prompt must satisfy.
+
+    Its own route rather than a name under /api/prompts, so a prompt called
+    `schema` cannot shadow it.
+    """
+    return client.get_json("/api/prompt-schema")
+
+
+def save_prompt(client, name, prompt):
+    """Write a prompt into the library, overwriting any prompt of that name.
+    The server validates before it writes."""
+    prompt = coerce_json_object(prompt, "prompt")
+    return client.put_json(api_path("api", "prompts", name), {"prompt": prompt})
+
+
+def delete_prompt(client, name):
+    """Remove a prompt from the library."""
+    return client.delete_json(api_path("api", "prompts", name))
+
+
+def list_enhancers(client):
+    """The enhancer presets `enhance_prompt` accepts, with descriptions."""
+    return client.get_json("/api/enhancers")
+
+
+def enhance_prompt(
+    client,
+    idea,
+    preset="h3",
+    model_name=None,
+    device=None,
+    acknowledged_cost=False,
+):
+    """Expand a short idea into a full prompt with a language model.
+
+    This is queued as an ordinary job, so it is gated like a run and returns
+    as soon as it is queued. The enhanced text arrives as the single text
+    file in the finished job's manifest.
+    """
+    if not acknowledged_cost:
+        raise DwApiError(ENHANCE_COST_REFUSAL)
+    payload = {"idea": idea, "preset": preset}
+    # Omitted rather than sent as null: absent means the preset's own default
+    # model and a CPU device, which is not what an explicit null would ask for
+    if model_name is not None:
+        payload["model_name"] = model_name
+    if device is not None:
+        payload["device"] = device
+    job = client.post_json("/api/enhance", payload)
+    return {
+        "job_id": job.get("id"),
+        "status": job.get("status"),
+        "queue_position": job.get("queue_position"),
+        "next": "Poll get_job(job_id) until it succeeds, then read the text "
+        "file in its manifest with get_output_text. Store the result with "
+        "save_prompt if it is worth keeping.",
+    }