AtCoderStudyBooster 0.4.1__py3-none-any.whl → 0.4.2__py3-none-any.whl

atcdr/ai.py

@@ -0,0 +1,434 @@
+import json
+import random
+import time
+from pathlib import Path
+from typing import Any, Callable, Dict, List, Optional
+
+import rich_click as click
+from openai import BadRequestError, OpenAI
+from rich.console import Console
+from rich.live import Live
+from rich.markup import escape
+from rich.panel import Panel
+from rich.syntax import Syntax
+from rich.table import Table
+from rich.text import Text
+
+from atcdr.test import (
+    LabeledTestCase,
+    ResultStatus,
+    TestCase,
+    TestRunner,
+)
+from atcdr.util.fileops import add_file_selector
+from atcdr.util.filetype import (
+    COMPILED_LANGUAGES,
+    FILE_EXTENSIONS,
+    INTERPRETED_LANGUAGES,
+    Lang,
+    str2lang,
+)
+from atcdr.util.i18n import _
+from atcdr.util.openai import set_api_key
+from atcdr.util.parse import ProblemHTML
+
+
+def render_result_for_GPT(test: TestRunner) -> tuple[str, bool]:
+    results = list(test)
+    match test.info.summary:
+        case ResultStatus.CE:
+            return f'Compile Error \n {test.info.compiler_message}', False
+        case _:
+            message_for_gpt = ''.join(
+                (
+                    f'\n{r.label} => {r.result.passed.value}, Execution Time : {r.result.executed_time}\n'
+                    f'\nInput :\n{r.testcase.input}\nOutput :\n{r.result.output}\nExpected :\n{r.testcase.output}\n'
+                    if r.result.passed == ResultStatus.WA
+                    else f'\n{r.label} => {r.result.passed.value}\nInput :\n{r.testcase.input}\nOutput :\n{r.result.output}\n'
+                )
+                for r in results
+            )
+            return message_for_gpt, False
+
+
+def display_test_results(console: Console, test: TestRunner) -> None:
+    results = list(test)
+
+    table = Table(title='🧪 Test Results')
+    table.add_column('Test Case', style='cyan', no_wrap=True)
+    table.add_column('Status', justify='center', no_wrap=True)
+    table.add_column('Input', style='dim', max_width=30)
+    table.add_column('Output', style='yellow', max_width=30)
+    table.add_column('Expected', style='green', max_width=30)
+
+    for r in results:
+        if r.result.passed == ResultStatus.AC:
+            status = '[green]✅ AC[/green]'
+        elif r.result.passed == ResultStatus.WA:
+            status = '[red]❌ WA[/red]'
+        elif r.result.passed == ResultStatus.TLE:
+            status = '[yellow]⏰ TLE[/yellow]'
+        elif r.result.passed == ResultStatus.RE:
+            status = '[red]💥 RE[/red]'
+        else:
+            status = f'[red]{r.result.passed.value}[/red]'
+
+        input_preview = escape(
+            r.testcase.input.strip()[:50] + '...'
+            if len(r.testcase.input.strip()) > 50
+            else r.testcase.input.strip()
+        )
+        output_preview = escape(
+            r.result.output.strip()[:50] + '...'
+            if len(r.result.output.strip()) > 50
+            else r.result.output.strip()
+        )
+        expected_preview = escape(
+            r.testcase.output.strip()[:50] + '...'
+            if len(r.testcase.output.strip()) > 50
+            else r.testcase.output.strip()
+        )
+
+        table.add_row(r.label, status, input_preview, output_preview, expected_preview)
+
+    console.print(table)
+
+
+def create_func(labeled_cases: list[LabeledTestCase], model: str):
+    def test_example_case(code: str, language: str) -> str:
+        language_enum: Lang = str2lang(language)
+        source_path = Path(f'{model}{FILE_EXTENSIONS[language_enum]}')
+        source_path.write_text(code, encoding='utf-8')
+        test = TestRunner(str(source_path), labeled_cases)
+        message_for_gpt, _ = render_result_for_GPT(test)
+        return message_for_gpt
+
+    def execute_code(input: Optional[str], code: str, language: str) -> str:
+        language_enum: Lang = str2lang(language)
+        random_name = random.randint(0, 100_000_000)
+        source_path = Path(f'tmp{random_name}{FILE_EXTENSIONS[language_enum]}')
+        source_path.write_text(code, encoding='utf-8')
+        labeled_cases = [LabeledTestCase('case by gpt', TestCase(input or '', ''))]
+        test = TestRunner(str(source_path), labeled_cases)
+        labeled_result = next(test)
+        source_path.unlink(missing_ok=True)
+        return labeled_result.result.output
+
+    return test_example_case, execute_code
+
+
+def solve_problem(path: Path, lang: Lang, model: str) -> None:
+    console = Console()
+    content = path.read_text(encoding='utf-8')
+    html = ProblemHTML(content)
+    md = html.make_problem_markdown('en')
+    labeled_cases = html.load_labeled_testcase()
+
+    test_example_case, execute_code = create_func(labeled_cases, model)
+
+    # Responses API 形式のツール定義（トップレベル）
+    TOOLS = [
+        {
+            'type': 'function',
+            'name': 'test_example_case',
+            'description': 'Run the given source code against example test cases and return a summarized result.',
+            'parameters': {
+                'type': 'object',
+                'properties': {
+                    'code': {'type': 'string'},
+                    'language': {
+                        'type': 'string',
+                        'enum': [
+                            lang.value
+                            for lang in (COMPILED_LANGUAGES + INTERPRETED_LANGUAGES)
+                        ],
+                    },
+                },
+                'required': ['code', 'language'],
+                'additionalProperties': False,
+            },
+            'strict': True,
+        },
+        {
+            'type': 'function',
+            'name': 'execute_code',
+            'description': 'Execute the given source code with a single input and return the actual output.',
+            'parameters': {
+                'type': 'object',
+                'properties': {
+                    'input': {'type': 'string'},
+                    'code': {'type': 'string'},
+                    'language': {
+                        'type': 'string',
+                        'enum': [
+                            lang.value
+                            for lang in (COMPILED_LANGUAGES + INTERPRETED_LANGUAGES)
+                        ],
+                    },
+                },
+                'required': ['input', 'code', 'language'],
+                'additionalProperties': False,
+            },
+            'strict': True,
+        },
+    ]
+
+    client = OpenAI()
+    if set_api_key() is None:
+        console.print('[red]OpenAI API key is not set.[/red]')
+        return
+
+    system_prompt = f"""You are a competitive programming assistant for {lang.value}.
+The user will provide problems in Markdown format.
+Read the problem carefully and output a complete, correct, and efficient solution in {lang.value}.
+Use standard input and output. Do not omit any code.
+Always pay close attention to algorithmic complexity (time and space).
+Choose the most optimal algorithms and data structures so that the solution runs within time limits even for the largest possible inputs.
+
+Use the provided tool test_example_case to run the example test cases from the problem statement.
+If tests do not pass, fix the code and repeat.
+The last tested code will be automatically saved to a local file on the user's computer.
+You do not need to include the final source code in your response.
+Simply confirm to the user that all tests passed, or briefly explain if they did not.
+Once you run test_example_case, the exact code you tested will already be saved locally on the user's machine, so sending it again in the response is unnecessary."""
+
+    # ツール名→ローカル実装のディスパッチ
+    tool_impl: Dict[str, Callable[..., Any]] = {
+        'test_example_case': test_example_case,
+        'execute_code': lambda **p: execute_code(
+            p.get('input', ''),  # ← 空なら空文字に
+            p.get('code', ''),
+            p.get('language', lang.value),
+        ),
+    }
+
+    console.print(f'Solving :{path} Language: {lang.value} / Model: {model}')
+
+    context_msgs = [
+        {'role': 'system', 'content': system_prompt},
+        {'role': 'user', 'content': md},
+    ]
+    turn = 1
+    assistant_text = Text()
+
+    def call_model():
+        try:
+            return client.responses.create(
+                model=model,
+                input=context_msgs,
+                tools=TOOLS,
+                tool_choice='auto',
+                include=['reasoning.encrypted_content'],
+                store=False,
+            )
+        except BadRequestError as e:
+            body = getattr(getattr(e, 'response', None), 'json', lambda: None)()
+            console.print(
+                Panel.fit(f'{e}\n\n{body}', title='API Error', border_style='red')
+            )
+            raise
+
+    while True:
+        start_time = time.time()
+        with Live(
+            Panel(
+                f'[bold blue]🤔 Thinking... (turn {turn})[/bold blue]\n[dim]Elapsed: 0.0s[/dim]',
+                border_style='blue',
+            ),
+            console=console,
+            refresh_per_second=10,
+        ) as live:
+
+            def update_timer():
+                elapsed = time.time() - start_time
+                live.update(
+                    Panel(
+                        f'[bold blue]🤔 Thinking... (turn {turn})[/bold blue]\n[dim]Elapsed: {elapsed:.1f}s[/dim]',
+                        border_style='blue',
+                    )
+                )
+
+            import threading
+
+            resp = None
+            error = None
+
+            def model_call():
+                nonlocal resp, error
+                try:
+                    resp = call_model()
+                except Exception as e:
+                    error = e
+
+            thread = threading.Thread(target=model_call)
+            thread.start()
+
+            while thread.is_alive():
+                update_timer()
+                time.sleep(0.1)
+
+            thread.join()
+
+            if error:
+                raise error
+
+            elapsed = time.time() - start_time
+            live.update(
+                Panel(
+                    f'[bold green]✓ Completed thinking (turn {turn})[/bold green]\n[dim]Time taken: {elapsed:.1f}s[/dim]',
+                    border_style='green',
+                )
+            )
+
+        # Display token usage
+        if resp and hasattr(resp, 'usage') and resp.usage:
+            usage = resp.usage
+            input_tokens = getattr(usage, 'input_tokens', 0)
+            output_tokens = getattr(usage, 'output_tokens', 0)
+            total_tokens = getattr(usage, 'total_tokens', 0)
+
+            # Check for cached tokens
+            cached_tokens = 0
+            if hasattr(usage, 'input_tokens_details'):
+                details = usage.input_tokens_details
+                if hasattr(details, 'cached_tokens'):
+                    cached_tokens = details.cached_tokens
+
+            # Check for reasoning tokens
+            reasoning_tokens = 0
+            if hasattr(usage, 'output_tokens_details'):
+                details = usage.output_tokens_details
+                if hasattr(details, 'reasoning_tokens'):
+                    reasoning_tokens = details.reasoning_tokens
+
+            token_msg = f'[dim]Tokens - Input: {input_tokens:,}'
+            if cached_tokens > 0:
+                token_msg += f' (cached: {cached_tokens:,})'
+            token_msg += f' | Output: {output_tokens:,}'
+            if reasoning_tokens > 0:
+                token_msg += f' (reasoning: {reasoning_tokens:,})'
+            token_msg += f' | Total: {total_tokens:,}[/dim]'
+            console.print(token_msg)
+
+        if resp and getattr(resp, 'output_text', None):
+            assistant_text.append(resp.output_text)
+
+            output_content = str(resp.output_text).strip()
+            if any(
+                keyword in output_content
+                for keyword in [
+                    'def ',
+                    'class ',
+                    'import ',
+                    'from ',
+                    '#include',
+                    'public class',
+                ]
+            ):
+                try:
+                    syntax = Syntax(
+                        output_content, lang, theme='monokai', line_numbers=True
+                    )
+                    console.print(
+                        Panel(
+                            syntax,
+                            title='Assistant Output (Code)',
+                            border_style='green',
+                        )
+                    )
+                except Exception:
+                    console.print(
+                        Panel(
+                            assistant_text,
+                            title='Assistant Output',
+                            border_style='green',
+                        )
+                    )
+            else:
+                console.print(
+                    Panel(
+                        assistant_text, title='Assistant Output', border_style='green'
+                    )
+                )
+
+        if resp and hasattr(resp, 'output'):
+            context_msgs += resp.output
+
+            # function_call を収集
+            calls: List[dict] = []
+            for o in resp.output:
+                if getattr(o, 'type', '') == 'function_call':
+                    try:
+                        args = json.loads(o.arguments or '{}')
+                    except Exception:
+                        args = {}
+                    call_id = getattr(o, 'call_id', None) or getattr(
+                        o, 'id'
+                    )  # ★ ここがポイント
+                    calls.append({'name': o.name, 'call_id': call_id, 'args': args})
+        else:
+            calls = []
+
+        if not calls:
+            console.print(
+                Panel.fit('✅ Done (no more tool calls).', border_style='green')
+            )
+            break
+
+        # ツールを実行し、function_call_output を context に積む
+        for c in calls:
+            args_str = json.dumps(c['args'], ensure_ascii=False) if c['args'] else ''
+            console.print(
+                Panel.fit(
+                    f"Tool: [bold]{c['name']}[/bold]\nargs: {args_str}",
+                    title=f"function_call ({c['call_id']})",
+                    border_style='cyan',
+                )
+            )
+
+            impl = tool_impl.get(c['name'])
+            if not impl:
+                out = f"[ERROR] Unknown tool: {c['name']}"
+            else:
+                try:
+                    with console.status(f"Running {c['name']}...", spinner='dots'):
+                        out = impl(**c['args']) if c['args'] else impl()
+                except TypeError:
+                    out = impl(
+                        **{
+                            k: v
+                            for k, v in c['args'].items()
+                            if k in impl.__code__.co_varnames
+                        }
+                    )
+                except Exception as e:
+                    out = f"[Tool '{c['name']}' error] {e}"
+
+            console.print(
+                Panel(
+                    str(out) or '(no output)',
+                    title=f"{c['name']} result",
+                    border_style='magenta',
+                )
+            )
+
+            context_msgs.append(
+                {
+                    'type': 'function_call_output',
+                    'call_id': c['call_id'],
+                    'output': str(out),
+                }
+            )
+
+        turn += 1
+
+
+@click.command(short_help=_('cmd_generate'), help=_('cmd_generate'))
+@add_file_selector('files', filetypes=[Lang.HTML])
+@click.option('--lang', default='Python', help=_('opt_output_lang'))
+@click.option('--model', default='gpt-5-mini', help=_('opt_model'))
+def ai(files, lang, model):
+    """HTMLファイルからコード生成またはテンプレート出力を行います。"""
+    lang_enum: Lang = str2lang(lang)
+    for path in files:
+        solve_problem(Path(path), lang_enum, model)

atcdr/cli.py

@@ -8,8 +8,8 @@ from rich.table import Table
 from rich.traceback import install
 from rich_click import RichGroup
 
+from atcdr.ai import ai
 from atcdr.download import download
-from atcdr.generate import generate
 from atcdr.login import login
 from atcdr.logout import logout
 from atcdr.markdown import markdown
@@ -76,7 +76,7 @@ def cli():
 cli.add_command(test, aliases=['t'])
 cli.add_command(download, aliases=['d'])
 cli.add_command(open_files, 'open', aliases=['o'])
-cli.add_command(generate, aliases=['g'])
+cli.add_command(ai)
 cli.add_command(markdown, aliases=['md'])
 cli.add_command(submit, aliases=['s'])
 cli.add_command(login)

atcdr/util/openai.py

@@ -0,0 +1,45 @@
+import os
+from typing import Optional
+
+import requests
+
+from atcdr.util.i18n import _
+
+
+def set_api_key() -> Optional[str]:
+    api_key = os.getenv('OPENAI_API_KEY')
+    if api_key and validate_api_key(api_key):
+        return api_key
+    elif api_key:
+        print(_('api_key_validation_failed'))
+    else:
+        pass
+
+    api_key = input(_('get_api_key_prompt'))
+    if validate_api_key(api_key):
+        print(_('api_key_test_success'))
+        print(_('save_api_key_prompt'))
+        if input() == 'y':
+            zshrc_path = os.path.expanduser('~/.zshrc')
+            with open(zshrc_path, 'a') as f:
+                f.write(f'export OPENAI_API_KEY={api_key}\n')
+            print(_('api_key_saved', zshrc_path))
+        os.environ['OPENAI_API_KEY'] = api_key
+        return api_key
+    else:
+        print(_('api_key_required'))
+        return None
+
+
+def validate_api_key(api_key: str) -> bool:
+    headers = {
+        'Content-Type': 'application/json',
+        'Authorization': f'Bearer {api_key}',
+    }
+
+    response = requests.get('https://api.openai.com/v1/models', headers=headers)
+    if response.status_code == 200:
+        return True
+    else:
+        print(_('api_key_validation_error'))
+        return False

atcdr/util/parse.py

@@ -110,7 +110,7 @@ class ProblemHTML(HTML):
     def load_labeled_testcase(self) -> List:
         from atcdr.test import LabeledTestCase, TestCase
 
-        problem_part = self.abstract_problem_part(i18n.language)
+        problem_part = self.abstract_problem_part('en')
         if problem_part is None:
             return []
 

{atcoderstudybooster-0.4.1.dist-info → atcoderstudybooster-0.4.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: AtCoderStudyBooster
-Version: 0.4.1
+Version: 0.4.2
 Summary: A tool to download and manage AtCoder problems.
 Project-URL: Homepage, https://github.com/yuta6/AtCoderStudyBooster
 Author-email: yuta6 <46110512+yuta6@users.noreply.github.com>
@@ -9,6 +9,7 @@ Requires-Python: >=3.8
 Requires-Dist: beautifulsoup4
 Requires-Dist: click-aliases>=1.0.5
 Requires-Dist: markdownify==0.13.1
+Requires-Dist: openai>=1.99.6
 Requires-Dist: pywebview>=5.4
 Requires-Dist: questionary>=2.0.1
 Requires-Dist: requests

{atcoderstudybooster-0.4.1.dist-info → atcoderstudybooster-0.4.2.dist-info}/RECORD

@@ -1,7 +1,7 @@
 atcdr/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-atcdr/cli.py,sha256=xiCnGf14VHtLcRlVHXNpLKW3FIxOHS2duTRDTsG8a5w,2595
+atcdr/ai.py,sha256=mjGfst2PaxgKskGkBVyrsNsSDlkgsQeyhPK9I8hOq-w,15894
+atcdr/cli.py,sha256=KPpnxqlvUwiXZdGmaO07bv3sRFJezjyXs0HPqF9r5I4,2562
 atcdr/download.py,sha256=sMILF_FKLTe3OBk_ZnA8pzvnlGz68jrHaU-lxDAy6pA,7678
-atcdr/generate.py,sha256=FBOPJ2wU827GzkmYxsFrZKJYKXVC_h675_9-mZ7wRdc,7899
 atcdr/login.py,sha256=3lyuo19EKOj3eaiOcOUnrkkgEEqWO0D1EnjLPKNxkPU,4655
 atcdr/logout.py,sha256=XwyR5oSipg-iQzfdfkx4Cs0Q88ZWJ548FmdhlIhpUL8,777
 atcdr/markdown.py,sha256=x0OORs1eun14c0XZWUap6HljTHhJ6UM6OfkJlDXeeSo,1587
@@ -11,12 +11,12 @@ atcdr/test.py,sha256=tbjkBETQG48AuH1F_hBlla3lpfcQiVvFO1YjZ2QDB9A,13518
 atcdr/util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 atcdr/util/fileops.py,sha256=kvQDO85Ii5n__Wo8KmoE6Ecgbxx9MfmF7BDYz1sL5Sk,3200
 atcdr/util/filetype.py,sha256=pceB08trkwNkdzKJx4fFfOWpz9jYMBRDwXLW4un0sRM,2254
-atcdr/util/gpt.py,sha256=GNJqgV-eVQlxkQ3tnwNiGec27FV6O4QSpwaDiXbFM0w,3392
 atcdr/util/i18n.py,sha256=WRptkwqRSYSpA7L2CeWwv4ufv_uK65KjnorAcOTOot8,17949
-atcdr/util/parse.py,sha256=fo_LtEXLwz0g3871iUKZFHMitxbBh-bz9uBndpKfQeI,7130
+atcdr/util/openai.py,sha256=BygabBuUmuD7wCyEujS4-79XpmLaBi8L_mGUq-JsTGs,1232
+atcdr/util/parse.py,sha256=fPcDqnb-COGJA49sc8HLNQBjCATII0edOtpe_sVIx0g,7121
 atcdr/util/problem.py,sha256=ZLD-WvhC5SC6TGbyqmiOpTVZVSn-KuhOazWvAvHdyqI,1222
 atcdr/util/session.py,sha256=xct266SY7QuC3bc1IKlkVginttvXE_qK5tepUx6hfWE,4820
-atcoderstudybooster-0.4.1.dist-info/METADATA,sha256=yV1OZY9piILs7WW_qfKEsGk_az03Vh4ehgrbq1iO-nQ,6077
-atcoderstudybooster-0.4.1.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
-atcoderstudybooster-0.4.1.dist-info/entry_points.txt,sha256=-stL-IwnheQGlYAdm82RuZu8CGgSakU0aVIVlA7DmFA,40
-atcoderstudybooster-0.4.1.dist-info/RECORD,,
+atcoderstudybooster-0.4.2.dist-info/METADATA,sha256=RKaWJkW3AiRZeIDRTQuhGshxruW7CvTo_lUbZmzi6gE,6107
+atcoderstudybooster-0.4.2.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
+atcoderstudybooster-0.4.2.dist-info/entry_points.txt,sha256=-stL-IwnheQGlYAdm82RuZu8CGgSakU0aVIVlA7DmFA,40
+atcoderstudybooster-0.4.2.dist-info/RECORD,,

atcdr/generate.py

@@ -1,197 +0,0 @@
-import json
-import os
-import re
-
-import rich_click as click
-from rich.console import Console
-from rich.panel import Panel
-from rich.syntax import Syntax
-
-from atcdr.test import ResultStatus, TestRunner, create_renderable_test_info
-from atcdr.util.fileops import add_file_selector
-from atcdr.util.filetype import (
-    FILE_EXTENSIONS,
-    Filename,
-    Lang,
-    lang2str,
-    str2lang,
-)
-from atcdr.util.gpt import ChatGPT, Model, set_api_key
-from atcdr.util.i18n import _
-from atcdr.util.parse import ProblemHTML
-
-
-def get_code_from_gpt_output(output: str) -> str:
-    pattern = re.compile(r'```(?:\w+)?\s*(.*?)\s*```', re.DOTALL)
-    match = pattern.search(output)
-    return match.group(1) if match else ''
-
-
-def render_result_for_GPT(
-    test: TestRunner,
-) -> tuple[str, bool]:
-    results = list(test)
-
-    match test.info.summary:
-        case ResultStatus.AC:
-            return 'Accepted', True
-        case ResultStatus.CE:
-            return f'Compile Error \n {test.info.compiler_message}', False
-        case _:
-            message_for_gpt = ''.join(
-                f'\n{result.label} => {result.result.passed.value}\nInput :\n{result.testcase.input}\nOutput :\n{result.result.output}\nExpected :\n{result.testcase.output}\n'
-                if result.result.passed == ResultStatus.WA
-                else f'\n{result.label} => {result.result.passed.value}\nInput :\n{result.testcase.input}\nOutput :\n{result.result.output}\n'
-                for result in results
-            )
-            return message_for_gpt, False
-
-
-def generate_code(file: Filename, lang: Lang, model: Model) -> None:
-    console = Console()
-    with open(file, 'r') as f:
-        html_content = f.read()
-    md = ProblemHTML(html_content).make_problem_markdown('en')
-
-    if set_api_key() is None:
-        return
-    gpt = ChatGPT(
-        system_prompt=f"""You are an excellent programmer. You solve problems in competitive programming.When a user provides you with a problem from a programming contest called AtCoder, including the Problem,Constraints, Input, Output, Input Example, and Output Example, please carefully consider these and solve the problem.Make sure that your output code block contains no more than two blocks. Pay close attention to the Input, Input Example, Output, and Output Example.Create the solution in {lang2str(lang)}.""",
-        model=model,
-    )
-    with console.status(_('generating_code', gpt.model.value)):
-        reply = gpt.tell(md)
-
-    code = get_code_from_gpt_output(reply)
-    console.print('[green][+][/green] ' + _('code_generation_success'))
-    console.rule(_('code_by_model', lang2str(lang), gpt.model.value))
-    console.print(Syntax(code=code, lexer=lang2str(lang)))
-
-    saved_filename = (
-        os.path.splitext(file)[0] + f'_by_{gpt.model.value}' + FILE_EXTENSIONS[lang]
-    )
-    with open(saved_filename, 'w') as f:
-        console.print('[green][+][/green] ' + _('code_saved', gpt.model.value, f.name))
-        f.write(code)
-
-
-def generate_template(file: Filename, lang: Lang) -> None:
-    console = Console()
-    with open(file, 'r') as f:
-        html_content = f.read()
-    md = ProblemHTML(html_content).make_problem_markdown('en')
-
-    if set_api_key() is None:
-        return
-    gpt = ChatGPT(
-        system_prompt='You are a highly skilled programmer. Your role is to create a template code for competitive programming.',
-        temperature=0.0,
-    )
-
-    propmpt = f"""
-The user will provide a problem from a programming contest called AtCoder. This problem will include the Problem Statement, Constraints, Input, Output, Input Example, and Output Example. You should focus on the Constraints and Input sections to create the template in {lang2str(lang)}.
-
-- First, create the part of the code that handles input. Then, you should read ###Input Block and ###Constraints Block.
-- After receiving the input, define variables in the program by reading ###Constraints Block and explain how to use the variables in the comment of your code block with example.
-- Last, define variables needed for output. Then you should read ###Output Block and ###Constraints Block.
-
-You must not solve the problem. Please faithfully reproduce the variable names defined in the problem.
-    """
-    with console.status(_('generating_template', lang2str(lang))):
-        reply = gpt.tell(md + propmpt)
-    code = get_code_from_gpt_output(reply)
-
-    savaed_filename = os.path.splitext(file)[0] + FILE_EXTENSIONS[lang]
-    with open(savaed_filename, 'x') as f:
-        console.print('[green][+][/green] ' + _('template_created', savaed_filename))
-        f.write(code)
-
-
-def solve_problem(file: Filename, lang: Lang, model: Model) -> None:
-    console = Console()
-    with open(file, 'r') as f:
-        html = ProblemHTML(f.read())
-
-    md = html.make_problem_markdown('en')
-    labeled_cases = html.load_labeled_testcase()
-
-    if set_api_key() is None:
-        return
-    gpt = ChatGPT(
-        system_prompt=f"""You are a brilliant programmer. Your task is to solve an AtCoder problem. AtCoder is a platform that hosts programming competitions where participants write programs to solve algorithmic challenges.Please solve the problem in {lang2str(lang)}.""",
-        model=model,
-    )
-
-    file_without_ext = os.path.splitext(file)[0]
-
-    for i in range(1, 4):
-        with console.status(_('nth_code_generation', i, gpt.model.value)):
-            if i == 1:
-                test_report = ''
-                reply = gpt.tell(md)
-            else:
-                prompt = f"""The following is the test report for the code you provided:
-                {test_report}
-Please provide an updated version of the code in {lang2str(lang)}."""
-                console.print(
-                    '[green][+][/] ' + _('regenerating_with_prompt', gpt.model.value)
-                )
-                console.print(Panel(prompt))
-                reply = gpt.tell(prompt)
-
-        code = get_code_from_gpt_output(reply)
-
-        saved_filename = (
-            f'{i}_'
-            + file_without_ext
-            + f'_by_{gpt.model.value}'
-            + FILE_EXTENSIONS[lang]
-        )
-        with open(saved_filename, 'w') as f:
-            console.print('[green][+][/] ' + _('code_generation_success_file', f.name))
-            f.write(code)
-
-        with console.status(
-            _('testing_generated_code', gpt.model.value), spinner='circleHalves'
-        ):
-            test = TestRunner(saved_filename, labeled_cases)
-            test_report, is_ac = render_result_for_GPT(test)
-
-        console.print(create_renderable_test_info(test.info))
-
-        if is_ac:
-            console.print('[green][+][/] ' + _('test_success'))
-            break
-        else:
-            console.print('[red][-][/] ' + _('test_failed'))
-
-    with open(
-        'log_'
-        + file_without_ext
-        + f'_by_{gpt.model.value}'
-        + FILE_EXTENSIONS[Lang.JSON],
-        'w',
-    ) as f:
-        console.print('[green][+][/] ' + _('log_saved', gpt.model.value, f.name))
-        f.write(json.dumps(gpt.messages, indent=2))
-    return
-
-
-@click.command(short_help=_('cmd_generate'), help=_('cmd_generate'))
-@add_file_selector('files', filetypes=[Lang.HTML])
-@click.option('--lang', default='Python', help=_('opt_output_lang'))
-@click.option('--model', default=Model.GPT41_MINI.value, help=_('opt_model'))
-@click.option('--without-test', is_flag=True, help=_('opt_without_test'))
-@click.option('--template', is_flag=True, help=_('opt_template'))
-def generate(files, lang, model, without_test, template):
-    """HTMLファイルからコード生成またはテンプレート出力を行います。"""
-    la = str2lang(lang)
-    model_enum = Model(model)
-
-    for path in files:
-        if template:
-            generate_template(path, la)
-        elif without_test:
-            generate_code(path, la, model_enum)
-        else:
-            solve_problem(path, la, model_enum)

atcdr/util/gpt.py

@@ -1,116 +0,0 @@
-import os
-from enum import Enum
-from typing import Dict, List, Optional
-
-import requests
-
-from atcdr.util.i18n import _
-
-
-class Model(Enum):
-    GPT4O = 'gpt-4o'
-    GPT41 = 'gpt-4.1'
-    GPT41_MINI = 'gpt-4.1-mini'
-    GPT41_NANO = 'gpt-4.1-nano'
-    GPT4O_MINI = 'gpt-4o-mini'
-    O1_PREVIEW = 'o1-preview'
-    O1 = 'o1'
-    O3 = 'o3'
-    O1_MINI = 'o1-mini'
-    O3_MINI = 'o3-mini'
-    O4_MINI = 'o4-mini'
-
-
-def set_api_key() -> Optional[str]:
-    api_key = os.getenv('OPENAI_API_KEY')
-    if api_key and validate_api_key(api_key):
-        return api_key
-    elif api_key:
-        print(_('api_key_validation_failed'))
-    else:
-        pass
-
-    api_key = input(_('get_api_key_prompt'))
-    if validate_api_key(api_key):
-        print(_('api_key_test_success'))
-        print(_('save_api_key_prompt'))
-        if input() == 'y':
-            zshrc_path = os.path.expanduser('~/.zshrc')
-            with open(zshrc_path, 'a') as f:
-                f.write(f'export OPENAI_API_KEY={api_key}\n')
-            print(_('api_key_saved', zshrc_path))
-        os.environ['OPENAI_API_KEY'] = api_key
-        return api_key
-    else:
-        print(_('api_key_required'))
-        return None
-
-
-def validate_api_key(api_key: str) -> bool:
-    headers = {
-        'Content-Type': 'application/json',
-        'Authorization': f'Bearer {api_key}',
-    }
-
-    response = requests.get('https://api.openai.com/v1/models', headers=headers)
-
-    if response.status_code == 200:
-        return True
-    else:
-        print(_('api_key_validation_error'))
-        return False
-
-
-class ChatGPT:
-    API_URL = 'https://api.openai.com/v1/chat/completions'
-
-    # APIの使い方 https://platform.openai.com/docs/api-reference/making-requests
-    def __init__(
-        self,
-        api_key: Optional[str] = None,
-        model: Model = Model.GPT41_MINI,
-        max_tokens: int = 3000,
-        temperature: float = 0.7,
-        messages: Optional[List[Dict[str, str]]] = None,
-        system_prompt: str = 'You are a helpful assistant.',
-    ) -> None:
-        self.api_key = api_key or os.getenv('OPENAI_API_KEY')
-        self.model = model
-        self.max_tokens = max_tokens
-        self.temperature = temperature
-        self.messages = (
-            messages
-            if messages is not None
-            else [{'role': 'system', 'content': system_prompt}]
-        )
-
-        self.__headers = {
-            'Content-Type': 'application/json',
-            'Authorization': f'Bearer {self.api_key}',
-        }
-
-    def tell(self, message: str) -> str:
-        self.messages.append({'role': 'user', 'content': message})
-
-        settings = {
-            'model': self.model.value,
-            'messages': self.messages,
-            'max_tokens': self.max_tokens,
-            'temperature': self.temperature,
-        }
-
-        response = requests.post(self.API_URL, headers=self.__headers, json=settings)
-        responsej = response.json()
-        try:
-            reply = responsej['choices'][0]['message']['content']
-        except KeyError:
-            print(_('response_format_error') + str(responsej))
-            return 'Error: Unable to retrieve response.'
-
-        self.messages.append({'role': 'assistant', 'content': reply})
-
-        # usage = responsej['usage']
-        # input_tokens = usage.get('prompt_tokens', 0)
-        # output_tokens = usage.get('completion_tokens', 0)
-
-        return reply