Нейронные сети (картинки)

source venv/Scripts/activate
pip install httpx==0.24.1

@echo off

set PYTHON=
set GIT=
set VENV_DIR=
set COMMANDLINE_ARGS= --autolaunch --xformers --medvram --opt-sdp-attention
git pull

call webui.bat

set COMMANDLINE_ARGS= --reinstall-xformers --xformers

app, local_url, share_url = shared.demo.launch(
            #share=cmd_opts.share,
            share=True,
            server_name=server_name,
            server_port=cmd_opts.port,
            ssl_keyfile=cmd_opts.tls_keyfile,
            ssl_certfile=cmd_opts.tls_certfile,
            debug=cmd_opts.gradio_debug,
            auth=[tuple(cred.split(':')) for cred in gradio_auth_creds] if gradio_auth_creds else None,
            inbrowser=cmd_opts.autolaunch,
            prevent_thread_lock=True
        )

import json
import urllib.error
import urllib.request


DEFAULT_SERVER_URL = "http://127.0.0.1:8085"


class LlamaCppPrompt:
    @classmethod
    def INPUT_TYPES(cls):
        return {
            "required": {
                "prompt": (
                    "STRING",
                    {
                        "multiline": True,
                        "default": "Write a short image prompt for a quiet cyberpunk street at night.",
                    },
                ),
            },
            "optional": {
                "system_prompt": (
                    "STRING",
                    {
                        "multiline": True,
                        "default": "",
                    },
                ),
                "server_url": (
                    "STRING",
                    {
                        "default": DEFAULT_SERVER_URL,
                    },
                ),
                "api_mode": (
                    [
                        "Auto",
                        "OpenAI chat",
                        "llama.cpp completion",
                    ],
                    {
                        "default": "Auto",
                    },
                ),
                "model": (
                    "STRING",
                    {
                        "default": "local",
                    },
                ),
                "temperature": (
                    "FLOAT",
                    {
                        "default": 0.7,
                        "min": 0.0,
                        "max": 2.0,
                        "step": 0.05,
                    },
                ),
                "top_p": (
                    "FLOAT",
                    {
                        "default": 0.9,
                        "min": 0.0,
                        "max": 1.0,
                        "step": 0.01,
                    },
                ),
                "max_tokens": (
                    "INT",
                    {
                        "default": 512,
                        "min": 1,
                        "max": 8192,
                        "step": 1,
                    },
                ),
                "seed": (
                    "INT",
                    {
                        "default": -1,
                        "min": -1,
                        "max": 2147483647,
                        "step": 1,
                    },
                ),
                "stop": (
                    "STRING",
                    {
                        "multiline": True,
                        "default": "",
                    },
                ),
                "timeout_seconds": (
                    "INT",
                    {
                        "default": 120,
                        "min": 1,
                        "max": 600,
                        "step": 1,
                    },
                ),
            },
        }

    RETURN_TYPES = ("STRING",)
    RETURN_NAMES = ("text",)
    FUNCTION = "generate"
    CATEGORY = "llama.cpp"

    def generate(
        self,
        prompt,
        system_prompt="",
        server_url=DEFAULT_SERVER_URL,
        api_mode="Auto",
        model="local",
        temperature=0.7,
        top_p=0.9,
        max_tokens=512,
        seed=-1,
        stop="",
        timeout_seconds=120,
    ):
        server_url = server_url.rstrip("/")
        stop_values = self._parse_stop(stop)

        if api_mode == "Auto":
            try:
                result = self._call_openai_chat(
                    server_url=server_url,
                    prompt=prompt,
                    system_prompt=system_prompt,
                    model=model,
                    temperature=temperature,
                    top_p=top_p,
                    max_tokens=max_tokens,
                    seed=seed,
                    stop_values=stop_values,
                    timeout_seconds=timeout_seconds,
                )
                if result[0].strip():
                    return result
            except RuntimeError as exc:
                if "HTTP 404" not in str(exc):
                    raise

            return self._call_llamacpp_completion(
                server_url=server_url,
                prompt=prompt,
                system_prompt=system_prompt,
                temperature=temperature,
                top_p=top_p,
                max_tokens=max_tokens,
                seed=seed,
                stop_values=stop_values,
                timeout_seconds=timeout_seconds,
            )

        if api_mode == "OpenAI chat":
            return self._call_openai_chat(
                server_url=server_url,
                prompt=prompt,
                system_prompt=system_prompt,
                model=model,
                temperature=temperature,
                top_p=top_p,
                max_tokens=max_tokens,
                seed=seed,
                stop_values=stop_values,
                timeout_seconds=timeout_seconds,
            )

        return self._call_llamacpp_completion(
            server_url=server_url,
            prompt=prompt,
            system_prompt=system_prompt,
            temperature=temperature,
            top_p=top_p,
            max_tokens=max_tokens,
            seed=seed,
            stop_values=stop_values,
            timeout_seconds=timeout_seconds,
        )

    def _call_openai_chat(
        self,
        server_url,
        prompt,
        system_prompt,
        model,
        temperature,
        top_p,
        max_tokens,
        seed,
        stop_values,
        timeout_seconds,
    ):
        url = f"{server_url}/v1/chat/completions"
        payload = self._chat_payload(
            prompt=prompt,
            system_prompt=system_prompt,
            model=model,
            temperature=temperature,
            top_p=top_p,
            max_tokens=max_tokens,
            seed=seed,
            stop_values=stop_values,
        )
        data = self._post_json(url, payload, timeout_seconds)
        return (self._clean_text(self._read_chat_text(data)),)

    def _call_llamacpp_completion(
        self,
        server_url,
        prompt,
        system_prompt,
        temperature,
        top_p,
        max_tokens,
        seed,
        stop_values,
        timeout_seconds,
    ):
        url = f"{server_url}/completion"
        payload = self._completion_payload(
            prompt=prompt,
            system_prompt=system_prompt,
            temperature=temperature,
            top_p=top_p,
            max_tokens=max_tokens,
            seed=seed,
            stop_values=stop_values,
        )
        data = self._post_json(url, payload, timeout_seconds)
        return (self._clean_text(self._read_completion_text(data)),)

    @staticmethod
    def _parse_stop(stop):
        values = [line.strip() for line in stop.splitlines() if line.strip()]
        return values or None

    @staticmethod
    def _clean_text(text):
        return text.strip()

    @staticmethod
    def _chat_payload(
        prompt,
        system_prompt,
        model,
        temperature,
        top_p,
        max_tokens,
        seed,
        stop_values,
    ):
        messages = []

        if system_prompt.strip():
            messages.append({"role": "system", "content": system_prompt})

        messages.append({"role": "user", "content": prompt})

        payload = {
            "model": model or "local",
            "messages": messages,
            "temperature": temperature,
            "top_p": top_p,
            "max_tokens": max_tokens,
            "stream": False,
        }

        if seed >= 0:
            payload["seed"] = seed

        if stop_values:
            payload["stop"] = stop_values

        return payload

    @staticmethod
    def _completion_payload(
        prompt,
        system_prompt,
        temperature,
        top_p,
        max_tokens,
        seed,
        stop_values,
    ):
        full_prompt = prompt

        if system_prompt.strip():
            full_prompt = f"{system_prompt.strip()}\n\n{prompt}"

        payload = {
            "prompt": full_prompt,
            "temperature": temperature,
            "top_p": top_p,
            "n_predict": max_tokens,
            "stream": False,
        }

        if seed >= 0:
            payload["seed"] = seed

        if stop_values:
            payload["stop"] = stop_values

        return payload

    @staticmethod
    def _post_json(url, payload, timeout_seconds):
        body = json.dumps(payload).encode("utf-8")
        request = urllib.request.Request(
            url,
            data=body,
            headers={
                "Content-Type": "application/json",
                "Accept": "application/json",
            },
            method="POST",
        )

        try:
            with urllib.request.urlopen(request, timeout=timeout_seconds) as response:
                raw = response.read().decode("utf-8")
        except urllib.error.HTTPError as exc:
            detail = exc.read().decode("utf-8", errors="replace")
            raise RuntimeError(f"llama.cpp request failed with HTTP {exc.code}: {detail}") from exc
        except urllib.error.URLError as exc:
            raise RuntimeError(f"Could not connect to llama.cpp at {url}: {exc.reason}") from exc

        try:
            return json.loads(raw)
        except json.JSONDecodeError as exc:
            raise RuntimeError(f"llama.cpp returned invalid JSON: {raw[:500]}") from exc

    @staticmethod
    def _read_chat_text(data):
        choices = data.get("choices") or []

        if choices:
            message = choices[0].get("message") or {}
            content = message.get("content")

            if content is not None:
                return content

            text = choices[0].get("text")

            if text is not None:
                return text

        raise RuntimeError(f"Could not read chat text from llama.cpp response: {data}")

    @staticmethod
    def _read_completion_text(data):
        content = data.get("content")

        if content is not None:
            return content

        choices = data.get("choices") or []

        if choices:
            text = choices[0].get("text")

            if text is not None:
                return text

        raise RuntimeError(f"Could not read completion text from llama.cpp response: {data}")


NODE_CLASS_MAPPINGS = {
    "LlamaCppPrompt": LlamaCppPrompt,
}

NODE_DISPLAY_NAME_MAPPINGS = {
    "LlamaCppPrompt": "Llama.cpp Prompt",
}

Get-CimInstance Win32_Process |
  Where-Object {
    $_.ExecutablePath -eq 'G:\ComfyUI\ComfyUI_windows_portable\python_embeded\python.exe' -and
    $_.CommandLine -like '*ComfyUI\main.py*'
  } |
  ForEach-Object { Stop-Process -Id $_.ProcessId }

Нарисуй обложку для статей по "Postgresql" как скетч с цветными зарисовками в разрешении 1:1
Текст на обложку не добавляй. 
На белом фоне. Минимальные отступы от изображения по бокам.