Program of Thoughts (PoT)

from openai import OpenAI
import re

client = OpenAI()


def program_of_thoughts(
    task: str,
    execute: bool = True,
) -> dict:
    """
    Program of Thoughts: генерация Python-кода
    для вычислительных задач.

    1. Модель генерирует код
    2. Код выполняется в безопасной песочнице
    3. Результат возвращается
    """
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[
            {
                "role": "system",
                "content": (
                    "Ты решаешь задачи, генерируя "
                    "Python-код. Правила:\n"
                    "1. Пиши чистый Python без "
                    "внешних зависимостей\n"
                    "2. Добавляй комментарии к шагам\n"
                    "3. В конце print() с ответом\n"
                    "4. Используй переменные с "
                    "понятными именами\n"
                    "5. Оборачивай код в ```python"
                ),
            },
            {
                "role": "user",
                "content": (
                    "Напиши Python-код для решения:\n"
                    f"{task}"
                ),
            },
        ],
        temperature=0,
    )

    code_text = response.choices[0].message.content

    # Извлечение кода из markdown-блока
    match = re.search(
        r"```python\n(.*?)```",
        code_text,
        re.DOTALL,
    )
    code = match.group(1).strip() if match else ""

    result = {"code": code, "raw_response": code_text}

    if execute and code:
        try:
            # Безопасное выполнение
            output_lines = []
            exec_globals = {"__builtins__": __builtins__}

            import io
            import contextlib

            f = io.StringIO()
            with contextlib.redirect_stdout(f):
                exec(code, exec_globals)

            result["output"] = f.getvalue().strip()
            result["success"] = True
        except Exception as e:
            result["output"] = str(e)
            result["success"] = False

    return result


result = program_of_thoughts(
    "Кредит 2 000 000 руб. под 16% годовых "
    "на 15 лет. Рассчитай аннуитетный платёж, "
    "общую переплату и переплату в процентах."
)
print("Код:", result["code"])
print("\nРезультат:", result["output"])

import anthropic
import re
import io
import contextlib

client = anthropic.Anthropic()


def pot_claude(task: str) -> dict:
    """
    Program of Thoughts через Claude.
    Генерация и выполнение кода.
    """
    message = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=2048,
        messages=[
            {
                "role": "user",
                "content": (
                    f"Задача: {task}\n\n"
                    "Реши задачу методом "
                    "Program of Thoughts:\n"
                    "1. Напиши Python-код "
                    "(без внешних библиотек)\n"
                    "2. Добавь комментарии\n"
                    "3. Выведи результат через print()"
                ),
            }
        ],
    )

    text = message.content[0].text
    match = re.search(
        r"```python\n(.*?)```", text, re.DOTALL
    )
    code = match.group(1).strip() if match else ""

    # Выполнение
    output = ""
    if code:
        f = io.StringIO()
        try:
            with contextlib.redirect_stdout(f):
                exec(code, {"__builtins__": __builtins__})
            output = f.getvalue().strip()
        except Exception as e:
            output = f"Ошибка: {e}"

    return {
        "code": code,
        "output": output,
        "explanation": text,
    }


result = pot_claude(
    "Компания тратит $3000/мес на LLM API. "
    "Кэширование снижает запросы на 40%, "
    "переход на мини-модель для простых задач "
    "(60% запросов) экономит 80% стоимости "
    "этих запросов. Какова экономия?"
)
print(result["output"])

from openai import OpenAI
import re
import io
import contextlib

client = OpenAI()


def pot_with_retry(
    task: str,
    max_retries: int = 3,
) -> dict:
    """
    PoT с автоисправлением: если код падает,
    передаём ошибку модели для исправления.
    """
    messages = [
        {
            "role": "system",
            "content": (
                "Генерируй Python-код для решения "
                "задач. Только стандартная библиотека. "
                "Код в ```python блоке."
            ),
        },
        {
            "role": "user",
            "content": f"Задача: {task}",
        },
    ]

    for attempt in range(max_retries):
        response = client.chat.completions.create(
            model="gpt-4o",
            messages=messages,
            temperature=0,
        )

        text = response.choices[0].message.content
        match = re.search(
            r"```python\n(.*?)```",
            text,
            re.DOTALL,
        )

        if not match:
            return {"error": "Код не найден"}

        code = match.group(1).strip()

        # Выполнение в песочнице
        f = io.StringIO()
        try:
            with contextlib.redirect_stdout(f):
                exec(
                    code,
                    {"__builtins__": __builtins__},
                )
            return {
                "code": code,
                "output": f.getvalue().strip(),
                "attempts": attempt + 1,
            }
        except Exception as e:
            error_msg = f"{type(e).__name__}: {e}"

            # Добавляем ошибку в контекст
            messages.append({
                "role": "assistant",
                "content": text,
            })
            messages.append({
                "role": "user",
                "content": (
                    f"Код вызвал ошибку:\n"
                    f"{error_msg}\n\n"
                    "Исправь код и попробуй снова."
                ),
            })

    return {"error": f"Не удалось за {max_retries} попыток"}


result = pot_with_retry(
    "Рассчитай IRR (internal rate of return) "
    "для инвестиции: начальные затраты $100K, "
    "денежные потоки по годам: "
    "$30K, $35K, $40K, $45K, $50K."
)
print(f"Попыток: {result.get('attempts', '?')}")
print(f"Результат: {result.get('output', result.get('error'))}")