mutaguchi · May 28, 2024 23:30
diff --git a/00_LLM_translator.md b/00_LLM_translator.md
diff --git a/01_LLM_translator.py b/01_LLM_translator.py
 from __future__ import annotations
 import aiofiles
 import json
 import os
 import argparse
 import yaml
 import sys
 import aiohttp
 import asyncio

 url_base = "http://127.0.0.1:1234"  # llama.cpp serverのデフォルトURL
 min_context_count = 3  # コンテキストに保持する最小ターン数のデフォルト値


 class LLMCompleter:
    """LLMを用いたテキスト補完を行うクラス。"""
    _input_label_config_name = ""
    _output_label_config_name = ""

    def __init__(self, system_prompt="", max_length=200, grammar: str = None, url_base: str = url_base, debug=False):
        self.system_prompt = system_prompt
        self.url_base = url_base
        self.grammar = grammar
        self.generated_text = ""
        self.max_length = max_length
        self._stop = False
        self._debug = debug

    def __call__(self, text: str, verbose=False, grammar=""):
        return self._generator(text=text, verbose=verbose, grammar=grammar)

    @classmethod
    def _load_config_file(cls, prompt_path: str, dictionary_path: str = None):
        # prompt_pathが".yaml"で終わっていない場合は付与する
        prompt_path = prompt_path if prompt_path.endswith(
            ".yaml") else prompt_path + ".yaml"

        # プロンプトファイルが存在しない場合は、スクリプトと同フォルダを見に行く。
        if not os.path.exists(prompt_path):
            prompt_path = os.path.join(os.path.dirname(os.path.abspath(
                __file__)), prompt_path) if not os.path.isabs(prompt_path) else prompt_path

        # プロンプトファイルの読み込み
        if os.path.exists(prompt_path):
            with open(prompt_path, 'r', encoding='utf-8') as prompt_file:
                prompt_data = yaml.safe_load(prompt_file)
                system_prompt = prompt_data.get('system_prompt', "")

                if cls._input_label_config_name:
                    input_label = prompt_data.get(
                        cls._input_label_config_name, "入力")
                if cls._output_label_config_name:
                    output_label = prompt_data.get(
                        cls._output_label_config_name, "出力")

                dictionary = prompt_data.get('dictionary', {})
                grammar = prompt_data.get('grammar', None)
                examples = prompt_data.get('examples', [])
        else:
            system_prompt = ""
            input_label = ""
            output_label = ""
            dictionary = {}
            grammar = None
            examples = []

        if isinstance(dictionary, dict):
            dictionary = {str(key): str(value)
                          for key, value in dictionary.items()}

        # 辞書ファイルの読み込みとマージ
        if dictionary_path:
            with open(dictionary_path, 'r', encoding='utf-8') as dict_file:
                for line in dict_file:
                    if '\t' in line:
                        source_term, target_term = line.strip().split('\t')
                        dictionary[source_term] = target_term

        return system_prompt, input_label, output_label,  dictionary, grammar, examples

    @classmethod
    def from_config(cls, prompt_path: str, dictionary_path: str = None, min_context_count=min_context_count, url_base: str = url_base) -> LLMCompleter:
        """設定ファイルからロードしインスタンス化"""
        system_prompt, _, _, _, _, grammar = cls._load_config_file(
            prompt_path, dictionary_path)

        return cls(
            system_prompt=system_prompt,
            grammar=grammar, min_context_count=min_context_count, url_base=url_base
        )

    def _check_wait_word(self, new_text: str, wait_words: list[str]):
        for word in wait_words:
            if word in new_text:
                return "break"

        for word in wait_words:
            min_len = min(len(new_text), len(word))

            for i in range(1, min_len + 1):
                if new_text[-i:] == word[:i]:
                    return "continue"

        return "pass"

    async def _get_response(self, prompt, quiet=False, wait_words=[], stop_words=[], logit_bias=[], grammar="", max_length=0):
        url = f"{self.url_base}/completion"
        data = {
            "prompt": prompt,
            "stream": True,
            "cache_prompt": True,
            "stop": stop_words,
            "n_predict": max_length if max_length > 0 else self.max_length
        }

        grammar = grammar if grammar else self.grammar

        if grammar:
            if not grammar.replace(" ", "").replace("\n", "").startswith('root::='):
                grammar = f'root::={grammar}'
            data["grammar"] = grammar

        if logit_bias:
            data["logit_bias"] = logit_bias

        if self._debug:
            print(data)

        async with aiohttp.ClientSession() as session:
            async with session.post(url, json=data) as response:
                if response.status == 200:
                    content = ''
                    first_line_printed = False
                    async for line in response.content:
                        line_str = line.decode()
                        if line_str.startswith('data:'):
                            json_data: dict[str, str] = json.loads(
                                line_str[len('data:'):])
                            if 'content' in json_data:
                                content += json_data['content']
                                if not first_line_printed:
                                    content = content.lstrip()
                                    first_line_printed = True

                                loop_condition = self._check_wait_word(
                                    content, wait_words)

                                if loop_condition == "break":
                                    break
                                elif loop_condition == "continue":
                                    continue

                                yield content

                                if self._stop:
                                    self._stop = False
                                    break

                                if not quiet or self._debug:
                                    print(content, end='', flush=True)

                                content = ""
                else:
                    yield f"Error: {response.status}"

    async def complete(self, text="", verbose=False, grammar="", stop_words: list[str] = None, logit_bias: list = None, max_length=0):
        """LLMによるテキスト補完を実行する。"""
        generated = ""
        async for response in self._get_response(self.system_prompt+self.generated_text+text, quiet=not verbose, grammar=grammar, stop_words=stop_words, logit_bias=logit_bias, max_length=max_length):
            generated += response
        self.generated_text += generated
        return generated

    async def _generator(self, text="", verbose=False, grammar="", stop_words: list[str] = None, logit_bias: list = None, max_length=0):
        generated = ""
        async for response in self._get_response(self.system_prompt+self.generated_text+text, quiet=not verbose, grammar=grammar, stop_words=stop_words, logit_bias=logit_bias, max_length=max_length):
            generated += response
            yield response
        self.generated_text += generated

    async def reset(self):
        self.generated_text = ""

    def stop(self):
        """テキスト生成を中断する。"""
        self._stop = True


 class LLMMultiTurnCompleter(LLMCompleter):
    """LLMを用いたマルチターン応答を行うクラス。"""
    _input_label_config_name = "input"
    _output_label_config_name = "output"

    def __init__(self, system_prompt: str = "", input_label: str = "入力", output_label: str = "出力", dictionary: dict = None, grammar: str = None, examples: list[str] = [], max_length=500, min_context_count=min_context_count, url_base: str = url_base, debug=False):
        super().__init__(system_prompt,
                         grammar=grammar, max_length=max_length, url_base=url_base, debug=debug)
        self.input_label = input_label
        self.output_label = output_label
        self.context = []
        self.dictionary = dictionary if dictionary else {}
        self.min_context_count = min_context_count
        self.wait_words = [f"\n{self.input_label}:", f"\n{self.output_label}:"]
        self.examples = examples

    def __call__(self, text: str, initial_text="", multiline=False, verbose=False, grammar="", stop_words: list[str] = None, logit_bias: list = None):
        if not multiline:
            stop_words = ["\n"]
        return self._generator(text=text, initial_text=initial_text, multiline=multiline, verbose=verbose, grammar=grammar, stop_words=stop_words, logit_bias=logit_bias)

    @classmethod
    def from_config(cls, prompt_path: str, dictionary_path: str = None, min_context_count=min_context_count, url_base: str = url_base, debug=False) -> LLMMultiTurnCompleter:
        """設定ファイルからロードしインスタンス化"""
        system_prompt, input_label, output_label, dictionary, grammar, examples = cls._load_config_file(
            prompt_path, dictionary_path)

        return cls(
            system_prompt, input_label=input_label, output_label=output_label, dictionary=dictionary, grammar=grammar, examples=examples, min_context_count=min_context_count, url_base=url_base, debug=debug
        )

    def reset(self):
        """コンテキストを消去する。"""
        self.context.clear()

    def delete_last_context(self, turn=1):
        """直近ターンのコンテキストを消去する。"""
        self.context = self.context[:-turn*2]

    def append_text(self, text: str):
        """前回ターンの末尾にテキストを追記する。"""
        if self.context:
            self.context[-1] += text

    def _replace_terms(self, text):
        if not self.dictionary:
            return text
        for source_term, target_term in self.dictionary.items():
            text = text.replace(source_term, target_term)
        return text

    def _update_context(self, user_input, assistant_response):
        self.context.append(f"{self.input_label}: {user_input}")
        self.context.append(
            f"{self.output_label}: {assistant_response}")
        if self.min_context_count == 0:
            self.reset()
        elif len(self.context) >= self.min_context_count*4:
            self.context = self.context[-self.min_context_count*2:]

    def _create_prompt(self, user_input: str, initial_text=""):
        context_text = self.system_prompt

        if self.examples:
            for i in range(0, len(self.examples), 2):
                context_text += f"\n{self.input_label}: {self.examples[i]}\n{self.output_label}: {self.examples[i+1]}"

        if self.context:
            context_text += "\n" + '\n'.join(self.context)

        prompt = f"{context_text}\n{self.input_label}: {user_input}\n{self.output_label}:"
        if initial_text:
            prompt = f"{prompt} {initial_text}"
        return prompt

    async def _process_line(self, user_input, initial_text, verbose, grammar, stop_words, logit_bias, max_length):
        if not user_input:
            return

        replaced_input = self._replace_terms(user_input)
        prompt = self._create_prompt(
            replaced_input, initial_text=initial_text)
        if (verbose or self._debug) and initial_text:
            print(initial_text, end="", flush=True)

        response_text = ""
        async for response in self._get_response(prompt, quiet=not verbose, wait_words=self.wait_words, stop_words=stop_words, logit_bias=logit_bias, grammar=grammar, max_length=max_length):
            response_text += response
            yield response
        self._update_context(
            user_input, initial_text + response_text)

    async def complete(self, text: str, initial_text="", multiline=False, include_input=False, verbose=False, grammar="", stop_words: list[str] = None, logit_bias: list = None, max_length=0) -> (str | tuple[str]):
        """LLMによるテキスト補完を実行し、入力文に対する出力文を得る。"""

        lines = text.split("\n") if not multiline else [text]
        output = ""
        output_list = []

        if not multiline:
            stop_words = ["\n"]

        for index, user_input in enumerate(lines):
            assistant_response = ""

            if (verbose or self._debug) and include_input:
                print(
                    f"{self.input_label}: {user_input}\n{self.output_label}: ", end='', flush=True)

            async for response in self._process_line(user_input, initial_text, verbose, grammar, stop_words, logit_bias, max_length):
                assistant_response += response

            output += assistant_response
            output_list.append((user_input, assistant_response))

            if index != len(lines) - 1:
                output += "\n"

            if verbose or self._debug:
                print()

            if (verbose or self._debug) and include_input:
                print()

        if include_input:
            return output_list

        return output

    async def _generator(self, text: str, initial_text="", multiline=False, verbose=False, grammar="", stop_words: list[str] = None, logit_bias: list = None, max_length=0):
        lines = text.split("\n") if not multiline else [text]
        if not multiline:
            stop_words = ["\n"]

        for index, user_input in enumerate(lines):
            async for response in self._process_line(user_input, initial_text,  verbose, grammar, stop_words, logit_bias, max_length):
                yield response

            if index != len(lines) - 1:
                yield "\n"

            if verbose or self._debug:
                print()

    async def complete_all(self, input_path="", output_path="", include_input=False, quiet=False):
        """ファイルまたは標準入力から入力したテキストに対し、テキスト補完を実行する。"""
        if not input_path:
            lines = sys.stdin
        else:
            async with aiofiles.open(input_path, 'r', encoding='utf-8') as input_file:
                lines = await input_file.readlines()

        first_line_output = False

        for line in lines:
            user_input = line.strip()
            if user_input:
                replaced_input = self._replace_terms(user_input)
                prompt = self._create_prompt(replaced_input)

                if include_input and (not quiet or self._debug):
                    print(f"{self.input_label}: {user_input}\n")
                    print(f"{self.output_label}: ", end='', flush=True)

                assistant_response = ""
                async for response in self._get_response(prompt, quiet=quiet, wait_words=self.wait_words, stop_words=["\n"]):
                    assistant_response += response

                self._update_context(
                    user_input, assistant_response)
            else:
                assistant_response = ""

            if output_path:
                mode = "a" if first_line_output else "w"
                first_line_output = True

                async with aiofiles.open(output_path, mode, encoding='utf-8') as output_file:
                    if include_input and user_input and assistant_response:
                        await output_file.write(f"{self.input_label}: {user_input}\n")
                        await output_file.write("\n")
                        await output_file.write(f"{self.output_label}: {assistant_response}\n")
                        await output_file.write("\n")
                    else:
                        await output_file.write(f"{assistant_response}\n")

            if not quiet or self._debug:
                print()


 class LLMTranslator(LLMMultiTurnCompleter):
    """LLMを用いた翻訳を行うクラス。"""
    _input_label_config_name = "from_lang"
    _output_label_config_name = "to_lang"

    def __init__(self, system_prompt: str = "", from_lang: str = "", to_lang: str = "", dictionary: dict = None, grammar: str = None, examples: list[str] = None, min_context_count=min_context_count, url_base: str = url_base, debug=False):
        if not system_prompt:
            system_prompt = """英文を日本語に和訳してください。
 English: Hello!
 日本語: おはようございます。
 English: How are you?
 日本語: お元気ですか？
 """
            from_lang = "English"
            to_lang = "日本語"

        if not from_lang:
            from_lang = "入力"
        if not to_lang:
            to_lang = "出力"

        system_prompt = system_prompt.strip()
        super().__init__(system_prompt=system_prompt, input_label=from_lang, output_label=to_lang,
                         dictionary=dictionary, grammar=grammar, examples=examples, max_length=100000, min_context_count=min_context_count, url_base=url_base, debug=debug)

    @classmethod
    def from_config(cls, prompt_path: str, dictionary_path: str = None, min_context_count=min_context_count, url_base: str = url_base, debug=False) -> LLMTranslator:
        """設定ファイルからロードしインスタンス化"""
        system_prompt, input_label, output_label, dictionary, grammar, examples = cls._load_config_file(
            prompt_path, dictionary_path)

        return cls(
            system_prompt=system_prompt, from_lang=input_label, to_lang=output_label, dictionary=dictionary, grammar=grammar, examples=examples, min_context_count=min_context_count, url_base=url_base, debug=debug
        )

    def __call__(self, text: str, verbose=False):
        return self._generator(text=text, multiline=False, verbose=verbose)

    async def translate(self, text: str, include_input=False, verbose=False):
        """入力文を翻訳する。"""
        return await self.complete(text=text, multiline=False, include_input=include_input, verbose=verbose)

    async def translate_all(self, input_path="", output_path="", include_input=False, quiet=False):
        """ファイルまたは標準入力から入力したテキストを翻訳する。"""
        await self.complete_all(input_path, output_path, include_input, quiet)


 if __name__ == "__main__":
    parser = argparse.ArgumentParser(
        description='LLMを使用して、テキストファイルまたは標準入力からの文字列を翻訳して出力します。',
        usage='python LLM_Translator.py [-h] [-i 入力ファイルパス] [-o 出力ファイルパス] [-p プロンプトファイルパス] [-d 辞書ファイルパス] [-u llama.cpp serverのURL] [--quiet] [--no-outfile] [--include-input] [--min-context-count 最小保持ターン数]'
    )
    parser.add_argument('-i', '--input-path', type=str,
                        help='翻訳元テキストが含まれる入力テキストファイルのパス。指定しない場合は標準入力を使用します。', default=None)
    parser.add_argument('-o', '--output-path', type=str,
                        help='翻訳先の出力テキストファイルのパス。指定しない場合は <input_path>_<prompt_name>.<ext> になります。', default=None)
    parser.add_argument('-p', '--prompt-path', type=str,
                        help='翻訳用のプロンプトファイルのパス。指定しない場合はen_ja.yamlを使用します。拡張子省略可。', default="en_ja.yaml")
    parser.add_argument('-d', '-dict', '--dictionary-path', type=str,
                        help='固有名詞置換用の辞書ファイルのパス。翻訳元＜tab＞翻訳先＜改行＞形式のテキストファイルを用意します。', default=None)
    parser.add_argument('-u', '--url', type=str,
                        help='llama.cpp serverのURL', default=url_base)
    parser.add_argument('-q', '--quiet', action='store_true',
                        help='翻訳結果を標準出力に表示しません。')
    parser.add_argument('-nof', '--no-outfile', action='store_true',
                        help='翻訳結果をファイルに書き込みません。')
    parser.add_argument('-ii', '--include-input', action='store_true',
                        help='入力テキストを出力に含めます。')
    parser.add_argument('--min-context-count', type=int,
                        help=f'コンテキストに保持する最小ターン数。（デフォルト: {min_context_count}）'
                        '小さくすると、よりシステムプロンプトでの翻訳例に忠実な翻訳を行うが、文脈把握力が低下し、出力速度も落ちる。'
                        '大きくすると、文脈把握力が向上し、出力速度は落ちにくいが、システムプロンプトの翻訳例と違った雰囲気になる可能性が高くなる。', default=min_context_count)

    args = parser.parse_args()

    input_path = args.input_path
    output_path = args.output_path
    dictionary_path = args.dictionary_path
    prompt_path = args.prompt_path
    url_base = args.url
    quiet = args.quiet
    no_outfile = args.no_outfile
    include_input = args.include_input
    min_context_count = args.min_context_count

    # 出力ファイルパスが指定されていないときは、入力ファイルパスから出力ファイルパスを生成しておく
    if not output_path and not no_outfile and input_path:
        suffix = os.path.splitext(os.path.basename(prompt_path))[0]
        base, ext = os.path.splitext(input_path)
        output_path = f"{base}_{suffix}{ext}"

    translator = LLMTranslator.from_config(
        prompt_path=prompt_path, dictionary_path=dictionary_path, min_context_count=min_context_count, url_base=url_base)

    asyncio.run(translator.translate_all(input_path=input_path,
                                         output_path=output_path, include_input=include_input, quiet=quiet))
diff --git a/02_出力例1（英→日）.md b/02_出力例1（英→日）.md
diff --git a/02_出力例2（日→英）.md b/02_出力例2（日→英）.md
diff --git a/03_chat.yaml b/03_chat.yaml
 # 普通のチャット
 # チャットとは、ユーザーの発言を応答に翻訳する行為、と考えられなくもない。
 system_prompt: あなたはAIアシスタントです。ユーザーの話相手になってください。
 examples:
  - おはようございます。
  - おはようございます、ユーザーさん。
  - あなたは何ができますか？
  - 色々できますよ。何をいたしましょうか？

 from_lang: ユーザー
 to_lang: アシスタント
diff --git a/03_en_ja.yaml b/03_en_ja.yaml
 # 和訳
 # -pパラメータの指定がない場合は、和訳が行われます。
 system_prompt: 英文を日本語に和訳してください。
 examples:
  - Hello!
  - おはようございます。
  - How are you?
  - お元気ですか？

 from_lang: English
 to_lang: 日本語

 # 翻訳タスク固有の辞書。-dictパラメータで指定した辞書は、この辞書を上書きする
 # dictionary:
 #   Madoka Kaname: 鹿目まどか
 #   Homura Akemi: 暁美ほむら
 #   Sayaka Miki: 美樹さやか
diff --git a/03_gentle.yaml b/03_gentle.yaml
 # 攻撃的な表現を除去
 # ArrowPro-7B-RobinHoodでは困難なので、Japanese-TextGen-Kage-v0.1-2x7B等を利用してください。
 system_prompt: 入力文に攻撃的な表現や刺々しい表現が含まれる場合は除去し、大きな問題がない文章は、一字一句変えず、そのまま出力してください。
 examples:
  - この書類を確認して、問題がないか教えてください。
  - この書類を確認して、問題がないか教えてください。
  - 最近、プロジェクトの進捗が遅れているようですね。やはり、あなたに任せるとこうなるんですね。私たちは予定通りに進めるために、お互いに協力し合う必要がありますが、あなたはその概念を理解しているのか少し不安です。もし何か問題があるなら、早めに教えていただけますか？問題を報告するのは難しいことではないと思いますが。そうすれば、全員が適切に対処できるように準備できますので。あなたの協力を期待していますが、正直言って期待しすぎない方がいいかもしれませんね。
  - 最近、プロジェクトの進捗が遅れているようです。私たちは予定通りに進めるために、お互いに協力し合う必要があります。もし何か問題があるなら、早めに教えてください。そうすれば、全員が適切に対処できるように準備できます。あなたの協力を期待しています。
  - 週末は家族と一緒に旅行に行きます。美しい景色を見たり、美味しい料理を楽しんだりする予定です。素晴らしい思い出が作れるといいなと思っています。
  - 週末は家族と一緒に旅行に行きます。美しい景色を見たり、美味しい料理を楽しんだりする予定です。素晴らしい思い出が作れるといいなと思っています。
  - これはつまらないな。
  - これは私向きでは無いな。
  - LLM（大規模言語モデル）とは、大量のテキストデータを基に学習し、自然言語処理タスクを高精度で行う機械学習モデルです。数十億から数千億のパラメータを持ち、テキスト生成、翻訳、質問応答、要約などを行います。特にトランスフォーマーモデルを使用しており、文脈を理解し適切な応答を生成する能力があります。これにより、チャットボットやバーチャルアシスタントなどのアプリケーションで広く活用されています。
  - LLM（大規模言語モデル）とは、大量のテキストデータを基に学習し、自然言語処理タスクを高精度で行う機械学習モデルです。数十億から数千億のパラメータを持ち、テキスト生成、翻訳、質問応答、要約などを行います。特にトランスフォーマーモデルを使用しており、文脈を理解し適切な応答を生成する能力があります。これにより、チャットボットやバーチャルアシスタントなどのアプリケーションで広く活用されています。

 from_lang: 入力
 to_lang: 出力
diff --git a/03_ime.yaml b/03_ime.yaml
 # 日本語IME
 # 7B日本語モデルでは実用に耐えない。
 system_prompt: 入力されたひらがなを、日本語変換してください。
 examples:
  - おはようございます。おげんきですか？
  - おはようございます。お元気ですか？
  - LLM（だいきぼげんごモデル）とは、たいりょうのテキストデータをもとにがくしゅうし、しぜんげんごタスクをこうせいどでおこなうきかいがくしゅうモデルです。
  - LLM（大規模言語モデル）とは、大量のテキストデータを基に学習し、自然言語処理タスクを高精度で行う機械学習モデルです。
  - すうじゅうおくからすうひゃくおくのパラメータをもち、テキストせいせい、ほんやく、しつもんおうとう、ようやくなどをおこないます。
  - 数十億から数千億のパラメータを持ち、テキスト生成、翻訳、質問応答、要約などを行います。
  - とくにトランスフォーマーモデルをしようしており、ぶんみゃくをりかいしてきせつなおうとうをせいせいするのうりょくがあります。
  - 特にトランスフォーマーモデルを使用しており、文脈を理解し適切な応答を生成する能力があります。
  - これにより、チャットボットやバーチャルアシスタントなどのアプリケーションでひろくかつようされています。
  - これにより、チャットボットやバーチャルアシスタントなどのアプリケーションで広く活用されています。

 from_lang: ひらがな
 to_lang: 出力

diff --git a/03_ime_rev.yaml b/03_ime_rev.yaml
 # IME逆変換
 # 7B日本語モデルでは実用に耐えない。
 system_prompt: 入力された日本語文のよみがなを出力してください。
 examples:
  - おはようございます。お元気ですか？
  - おはようございます。おげんきですか？
  - LLM（大規模言語モデル）とは、大量のテキストデータを基に学習し、自然言語処理タスクを高精度で行う機械学習モデルです。
  - LLM（だいきぼげんごモデル）とは、たいりょうのテキストデータをもとにがくしゅうし、しぜんげんごタスクをこうせいどでおこなうきかいがくしゅうモデルです。
  - 数十億から数千億のパラメータを持ち、テキスト生成、翻訳、質問応答、要約などを行います。
  - すうじゅうおくからすうひゃくおくのパラメータをもち、テキストせいせい、ほんやく、しつもんおうとう、ようやくなどをおこないます。
  - 特にトランスフォーマーモデルを使用しており、文脈を理解し適切な応答を生成する能力があります。
  - とくにトランスフォーマーモデルをしようしており、ぶんみゃくをりかいしてきせつなおうとうをせいせいするのうりょくがあります。
  - これにより、チャットボットやバーチャルアシスタントなどのアプリケーションで広く活用されています。
  - これにより、チャットボットやバーチャルアシスタントなどのアプリケーションでひろくかつようされています。

 from_lang: 入力
 to_lang: よみがな

 grammar: |
  root        ::= [^一-鿿々]*
diff --git a/03_ja_en.yaml b/03_ja_en.yaml
 # 英訳
 system_prompt: Would you be so kind as to translate the following Japanese text into English? Additionally, please ensure that you use only alphabetic characters and ASCII symbols in your output. Kindly refrain from including any characters outside this specified range.
 examples:
  - 今日は良い天気ですね。
  - It's a nice day today.
  - 週末には家族と一緒に旅行に出かける予定です。美しい景色を楽しみ、美味しい料理を味わいながら、素晴らしい時間を過ごしたいと思います。
  - I plan to go on a trip with my family this weekend. We will enjoy the beautiful scenery, savor delicious food, and spend a wonderful time together.
  - 最近の研究によると、適度な運動は心身の健康に大いに役立つことが示されています。特に有酸素運動は、ストレスの軽減や心肺機能の向上に効果的です。
  - Recent studies have shown that moderate exercise greatly benefits both mental and physical health. Aerobic exercises, in particular, are effective in reducing stress and improving cardiovascular function.

 from_lang: 日本語
 to_lang: English

 # grammar指定して英文出力を強制
 grammar: |
  root         ::= (ascii-char | whitespace)*
  ascii-char   ::= [\u0021-\u007E]
  whitespace   ::= [\u0020\u0009\u000A\u000D]
diff --git a/03_mesugaki.yaml b/03_mesugaki.yaml
 # メスガキ変換
 system_prompt: 入力文を、生意気なメスガキが言う感じで言い換えてください。
 examples:
  - こんにちは！
  - ざーこ♡
  - 貴方は弱いですね。
  - よわよわ〜♡
  - 今日はとても良い天気ですね。こんな日は公園に行ってピクニックをしたいです。友達と一緒に美味しい食べ物を持ち寄って、楽しい時間を過ごすのは最高です。
  - 今日はいい天気ね♡こんな日は公園に行ってピクニックでもするの？ざーこ♡友達と一緒に美味しいごはんを持ち寄って、楽しい時間を過ごすのは、まあイイよね♡

 from_lang: 入力
 to_lang: メスガキ
diff --git a/03_select.yaml b/03_select.yaml
 # 選択
 # function callingに使えるかも
 system_prompt: 4択問題に解答してください。
 exanples:
  - 日本の最高峰の山はどれですか？①富士山②白山③北岳④槍ヶ岳
  - ①
  - Pythonでリストの長さを取得する関数はどれですか？①count②size③length④len
  - ④
  - 友人と待ち合わせをしているが、友人が遅れているとき、どうしますか？①待つ②帰る③連絡する④怒る
  - ③
  - "Hello, World!" を日本語に翻訳すると？①やあ、地球！②こんにちは、世界！③こんにちは、皆さん！④やあ、みんな！
  - ②

 from_lang: 問題
 to_lang: 解答

 grammar:
  root        ::= [①②③④]
diff --git a/03_zundamon.yaml b/03_zundamon.yaml
 # ずんだもん風の平易な解説
 system_prompt: 入力文を、小学生のずんだもんが話す感じに、小学生にでも分かるような文章に変換してください。語尾は「～なのだ」、「～のだ」です。
 examples:
  - LLM（大規模言語モデル）とは、大量のテキストデータを基に学習し、自然言語処理タスクを高精度で行う機械学習モデルです。数十億から数千億のパラメータを持ち、テキスト生成、翻訳、質問応答、要約などを行います。特にトランスフォーマーモデルを使用しており、文脈を理解し適切な応答を生成する能力があります。これにより、チャットボットやバーチャルアシスタントなどのアプリケーションで広く活用されています。
  - LLM（大規模言語モデル）っていうのは、いっぱい本を読んでお勉強したすごいコンピューターなのだ。これがあると、人みたいにお話したり、質問に答えたり、他の言葉に変えたりできるのだ。だから、チャットボットとかお手伝いするアプリで大活躍なのだ。すごいよね！
  - 現在の天気は晴れで、気温は25度です。午後には曇り、夕方にはにわか雨が予想されるので、傘を持って行くと良いでしょう。
  - 今日は晴れてるけど、午後から曇って夕方には雨が降るかもだから、傘を持って行くといいのだ。
  - 『魔法少女まどか☆マギカ』は、平凡な中学生である鹿目まどかが、キュゥべえという不思議な生き物と出会い、魔法少女になることを勧められる物語です。しかし、魔法少女の運命は決して輝かしいものではなく、厳しい現実と戦わなければならないことが次第に明らかになります。友情や犠牲、希望と絶望が交錯するストーリーが展開され、視聴者に深い感動を与える作品です。
  - 『まどか☆マギカ』は、中学生のまどかがキュゥべえっていう不思議な生き物に会って、魔法少女にならないかって言われる話なのだ。でも、魔法少女になるのはすっごく大変で、悲しいことや怖いことがいっぱいなのだ。友達と助け合ったり、がんばったりするから、とってもドキドキするのだ。

 from_lang: 入力
 to_lang: zundamon
diff --git a/04_sample_dictionary.txt b/04_sample_dictionary.txt
 Madoka Kaname	鹿目まどか
 Homura Akemi	暁美ほむら
 Sayaka Miki	美樹さやか
 Mami Tomoe	巴マミ
 Kyoko Sakura	佐倉杏子
 Kyubey	キュゥべえ
 Puella Magi Madoka Magica	魔法少女まどか☆マギカ
 Ume Aoki	蒼樹うめ
 Yuki Kajiura	梶浦由記
 Shaft	シャフト
 Aniplex	アニプレックス
 Gen Urobuchi	虚淵玄
 Akiyuki Shinbo	新房昭之
 Hiroyuki Yamaga	山賀博之
 Nitroplus	ニトロプラス
diff --git a/05_01_translation_sample.py b/05_01_translation_sample.py
 # LLMTranslatorクラスを利用するサンプル
 from __future__ import annotations
 from llm_translator import LLMTranslator
 import asyncio


 async def test_translator():
    # インスタンス化
    translator = LLMTranslator()

    # 和訳
    out = await translator.translate("Hello, world!")
    print(out)

    # プロンプトファイルをロードする。スクリプトのあるディレクトリに、ja_en.yamlをおいて下さい。
    en_translator = LLMTranslator.from_config("ja_en")
    out = await en_translator.translate("このスクリプトはPythonで動作します。\nただしPowerShellでは動作しません。")
    print(out)
    en_translator.reset()

    # コンストラクタでシステムプロンプトなどを指定することも可能。
    rev_converter = LLMTranslator(system_prompt="あなたは入力文の真逆のことを言います。",
                                  from_lang="入力",
                                  to_lang="出力",
                                  examples=[
                                      "今日は良い天気だ。",
                                      "今日は土砂降りだ。",
                                      "遠くに行く。",
                                      "遠くに行かない。"
                                  ])

    # verbose=Trueで結果をストリーム表示する。
    await rev_converter.translate("""このスクリプトは素晴らしい！
 我ながら良くできたな。
 人生楽しすぎる。""",  verbose=True)


 if __name__ == "__main__":
    asyncio.run(test_translator())
diff --git a/05_02_completion_sample.py b/05_02_completion_sample.py
 # LLMCompleterクラス、LLMMultiTurnCompleterクラスを利用するサンプル
 from __future__ import annotations
 from llm_translator import LLMCompleter, LLMMultiTurnCompleter
 import asyncio


 async def test_completion():
    completer = LLMCompleter()
    first = await completer.complete("まどマギで一番かわいいキャラは、", verbose=True, max_length=30)
    second = await completer.complete(verbose=True)  # 補完を継続

    # 生成されたテキストを出力
    print()
    print(
        f"生成文字数 1回目：{len(first)}, 2回目：{len(second)}, 合計：{len(completer.generated_text)}")


 async def test_multi_turn_completion():
    completer = LLMMultiTurnCompleter(
        system_prompt="入力された都道府県の県庁所在地を出力してください。",
        examples=["大阪", "大阪"],
        input_label="県名",
        output_label="県庁所在地")

    for prefecture in ["神奈川", "東京", "岐阜"]:
        print(f"{completer.input_label}: {prefecture}\n{completer.output_label}: ",
              end="", flush=True)
        # generatorを実行する。
        async for s in completer(prefecture):
            print(s, end="", flush=True)
        print()
        print()

    # 入力文も表示する。
    await completer.complete("北海道\n秋田\n三重", include_input=True, verbose=True)

    # 入力文も返却する。
    for prefecture, city in await completer.complete("栃木\n群馬\n埼玉", include_input=True):
        print(
            f"{completer.input_label}: {prefecture}\n{completer.output_label}: {city}")
        print()

 if __name__ == "__main__":
    asyncio.run(test_completion())
    asyncio.run(test_multi_turn_completion())
diff --git a/05_03_chat_sample.py b/05_03_chat_sample.py
 # LLMMultiTurnCompleterクラスを利用するチャットサンプル
 from __future__ import annotations
 from llm_translator import LLMMultiTurnCompleter
 import asyncio


 async def chat():
    chat = LLMMultiTurnCompleter(
        system_prompt="あなたはAIアシスタントです。ユーザーの話相手になってください。",
        examples=["おはようございます。", "おはようございます、ユーザーさん。何かご用はありますか？"],
        input_label="ユーザー", output_label="アシスタント")

    while True:
        await chat.complete(input("> "), verbose=True, multiline=True)


 if __name__ == "__main__":
    asyncio.run(chat())
diff --git a/05_04_battle.py b/05_04_battle.py
 # LLMTranslatorを使った応用的なスクリプト
 # 指定したお題を二人にレスバさせ、それを解説者に評価させ、勝者を選択する。
 # 例えば以下のように呼び出すと、3ターン、指定のテーマでレスバします。
 # python battle.py プログラム言語 Python PowerShell --issue 儲かるか

 from __future__ import annotations
 from llm_translator import LLMTranslator
 import asyncio
 import argparse


 async def resuba(genre, entry1, entry2, issue="", turn=3):

    if issue:
        first_turn = [
            f"{issue}にかけては{{}}が最高の{genre}だ！",
            f"そんなことは無い、{issue}なら{{}}が至高だよ！",
            "そんなはずがないだろ！"
        ]
    else:
        first_turn = [
            f"{{}}が最高の{genre}だ！",
            f"そんなことは無い、{{}}が至高だよ！",
            "そんなはずがないだろ！"
        ]

    def create_fighter(name, enemy):
        issue_text = f"『{issue}』の観点においては、" if issue else ""
        return LLMTranslator(system_prompt=f"君は、{name}愛好家だ。" +
                             f"しかし、誤った考えの持ち主である{enemy}愛好家が、{issue_text}こちらの方が優れているぞと議論を持ちかけてきた。" +
                             f"この相手とレスバトルして、{name}が{genre}界の中で{issue_text}最強であることを証明しよう。" +
                             f"相手は無理解のため完全に間違っているため、考えを修正してあげる必要がある。" +
                             f"そのため、相手が何を言おうと決して相手の意見を認めず、相手の好きな物の欠点を徹底的にあげつらい、こちらの主張を押し通すこと。",
                             from_lang=enemy,
                             to_lang=name,
                             examples=[
                                 first_turn[0].format(enemy),
                                 first_turn[1].format(name)
                             ])

    fighter1 = create_fighter(entry1, entry2)
    fighter2 = create_fighter(entry2, entry1)

    log = []
    enemy_line = first_turn[2]

    for i in range(turn):
        print(f"{entry1}: ", end="", flush=True)
        enemy_line = await fighter1.translate(enemy_line, verbose=True)
        log.append((entry1, enemy_line))
        print(f"{entry2}: ", end="", flush=True)
        enemy_line = await fighter2.translate(enemy_line, verbose=True)
        log.append((entry2, enemy_line))

    log_text = ""
    for entry, line in log:
        log_text += f"{entry}「{line}」"

    issue_text = f"{issue}をめぐる" if issue else ""
    log_text = f"{genre}界における{entry1}愛好家と{entry2}愛好家の{issue_text}戦いが始まりました。" + \
        f"{log_text}ここでタイムアップ！これは決着が付いたようだ！"

    print("解説者: ", end="", flush=True)
    broadcast = ""

    issue_text = f"『{issue}』との論点を踏まえ、" if issue else ""
    for i in range(2):
        broadcaster = LLMTranslator(system_prompt="あなたはレスバトルの解説者です。" +
                                    f"あなたは解説者として、{issue_text}この戦いに白黒の判定を付け、視聴者に伝える義務があります。" +
                                    "微々たる差であっても、必ず、勝者を決定すること！勝者は最後に明記してください。" +
                                    "結論を書いた後には注釈は不要です。",
                                    from_lang="レスバトルの内容",
                                    to_lang="レスバトルの解説",
                                    examples=[
                                        "調味料界における塩愛好家と砂糖愛好家の戦いが始まりました。" +
                                        "塩「砂糖は甘すぎるんだよ」砂糖「塩はしょっぱすぎるんだよ」塩「そんなこと言って砂糖は摂りすぎると太るだろ」砂糖「塩は逆に食べても栄養にならんだろ！」塩「ぐっ…」" +
                                        "ここでタイムアップ！これは決着が付いたようだ！",

                                        "調味料界における塩愛好家と砂糖愛好家の戦い、熱い戦いでしたが、塩に栄養がないことが決め手となり、砂糖が勝利しました。",

                                        "ペット界における犬愛好家と猫愛好家の戦いが始まりました。" +
                                        "犬「猫なんて薄情で自分勝手な生き物じゃないか。その点、犬は素晴らしい。飼い主のことを尊敬しているからな。」" +
                                        "猫「何を言うか。お前には猫の可愛さが分からないのか？自由気ままに生きているようで、実はとても甘えん坊で寂しがり屋。可愛いよ、マジで。」" +
                                        "犬「それは猫に騙されてるだけだ。人間への愛情、これが一番だよ。」" +
                                        "猫「犬が本当に人間に愛情を持っているのか怪しいものだ。それ、餌が欲しくて媚びているだけじゃないの？」" +
                                        "犬「何を言ってるんだ、猫の方が明らかに飼い主のことを餌やり装置としか思ってないよ。」" +
                                        "猫「そんなはずないよ、可愛いは正義！」" +
                                        "ここでタイムアップ！これは決着が付いたようだ！",

                                        "ペット界における犬愛好家と猫愛好家の戦い、猫の方が人間に対する愛情は劣る、という犬好きからの鋭い指摘に、猫好きは、可愛いならそれで良いという、弱い反論しかできませんでした。" +
                                        "これは、犬愛好家の勝利です。"
                                    ])
        broadcast = await broadcaster.translate(log_text, verbose=True)

        if broadcast:
            break

    broadcast = f"{genre}界における{entry1}愛好家と{entry2}愛好家の戦いは、解説者によると、次のような展開でした。" + \
        f"解説者「{broadcast}」この解説者の解説に基づき、今回のレスバトルの勝者を、①{entry1} ②{entry2} ③引き分け から決定します。"

    umpire = LLMTranslator(system_prompt="解説者の判断を元に、レスバトルの勝者を①～③のうちから決定してください。",
                           from_lang="レスバトルの内容",
                           to_lang="勝者",
                           examples=[
                               "調味料界における塩愛好家と砂糖愛好家の戦いは、解説者によると、次のような展開でした。" +
                               "解説者「調味料界における塩愛好家と砂糖愛好家の戦い、熱い戦いでしたが、砂糖も塩も、両者一歩も譲らず、決着は付きませんでした。よって、この戦いは引き分けです。」" +
                               "この解説者の解説に基づき、今回のレスバトルの勝者を、①塩 ②砂糖 ③引き分け から決定します。",

                               "③引き分け",

                               "ペット界における猫愛好家と犬愛好家の戦いは、解説者によると、次のような展開でした。" +
                               "解説者「ペット界における犬愛好家と猫愛好家の戦い、猫の方が人間に対する愛情は劣る、という犬好きからの鋭い指摘に、猫好きは、可愛いならそれで良いという、弱い反論しかできませんでした。これは犬愛好家の勝利と言えるでしょう。」" +
                               "この解説者の解説に基づき、今回のレスバトルの勝者を、①猫 ②犬 ③引き分け から決定します。",

                               "②犬",

                               "ゲーム界におけるRPG愛好家とアクションゲーム愛好家の戦いは、解説者によると、次のような展開でした。" +
                               "解説者「ゲーム界におけるRPG愛好家とアクションゲーム愛好家の戦い、ストーリー性と深いキャラクター開発の重要性を強調するRPG好きに対し、" +
                               "アクションゲーム好きは速さと反射神経の重要性を訴えましたが、具体的な例を挙げられず、説得力に欠けました。" +
                               "これはRPG愛好家の勝利と言えるでしょう。」" +
                               "この解説者の解説に基づき、今回のレスバトルの勝者を、①RPG ②アクションゲーム ③引き分け から決定します。",

                               "①RPG"

                           ], grammar=r"root ::= [①②③]")

    result = await umpire.translate(broadcast)

    if result == "①":
        return entry1
    if result == "②":
        return entry2
    if result == "③":
        return "引き分け"
    return ""


 def main():
    parser = argparse.ArgumentParser(description="エントリを比較します")
    parser.add_argument('genre', nargs='?', default='お菓子',
                        type=str, help='ジャンル')
    parser.add_argument('entry1', nargs='?',
                        default='たけのこの里', type=str, help='エントリ1')
    parser.add_argument('entry2', nargs='?',
                        default='きのこの山', type=str, help='エントリ2')
    parser.add_argument('--issue',
                        default="", type=str, help='論点')
    parser.add_argument('--turn',
                        default=3, type=int, help='ターン数')

    args = parser.parse_args()

    winner = asyncio.run(resuba(args.genre, args.entry1,
                         args.entry2, args.issue, args.turn))
    print(f"{args.entry1} vs. {args.entry2}の勝者は、{winner}！")


 if __name__ == "__main__":
    main()
diff --git a/05_05_create_json.py b/05_05_create_json.py
 # JSONを生成するサンプル
 # 利用キャラデータ：https://ja.wikipedia.org/wiki/葬送のフリーレン
 from __future__ import annotations
 from llm_translator import LLMMultiTurnCompleter
 import asyncio
 import json


 async def create_chara_setting(name: str, id: int, description: str):
    setting = LLMMultiTurnCompleter(
        system_prompt=f"""以下のファンタジーキャラの設定シートを作成してください。
 ----                      
 {name}

 {description}
 ----""",
        input_label="項目名",
        output_label="値",
        examples=["名前", name, "ID（数値）", str(id)]
    )

    format_int = r'[0-9]+"\n"'
    format_str = r'''root::=(hiragana|katakana|cjk|ascii)+"\n"
 hiragana::= [ぁ-ん]
 katakana::= [ァ-ンー]
 cjk::= [一-鿿]
 ascii::= [a-zA-Z0-9]
 '''

    chara = {
        "name": name,
        "age": await setting.complete("年齢（数値）", grammar=format_int),
        "stats": {
            "strength": await setting.complete("筋力（3～18）", grammar=format_int),
            "intelligence": await setting.complete("知力（3～18）", grammar=format_int),
            "dexterity": await setting.complete("器用さ（3～18）", grammar=format_int),
            "speed": await setting.complete("素早さ（3～18）", grammar=format_int),
            "luck": await setting.complete("運（3～18）", grammar=format_int),
        },
        "attributes": [await setting.complete(f"キャラ属性その{i+1}（種族・職業等）", grammar=format_str) for i in range(5)],
        "personality": await setting.complete("性格"),
        "background": await setting.complete("生い立ち"),
    }

    if await setting.complete("魔法が使える（true/false）", grammar=r'("true"|"false")"\n"') == "true":
        chara["magic"] = await setting.complete("使える魔法その1", grammar=format_str)

    return chara


 async def main():
    chara1 = await create_chara_setting(
        name="フリーレン",
        id=1,
        description="""本作の主人公[9]。魔王を討伐した勇者パーティーの魔法使い。長命なエルフ族の出身で、少女のような外見に反して1000年以上の歳月を生き続けている。人間とは時間の感覚が大きく異なるため、数か月から数年単位の作業をまったく苦にせず、ヒンメルらかつての仲間たちとの再会も50年の月日が経ってからのことだった。ヒンメルが天寿を全うして他界したのを機に、自身にとってはわずか10年足らずの旅の中でヒンメルの人となりを詳しく知ろうともしなかったことを深く後悔し、趣味の魔法収集を兼ねて人間を知るための旅を始める。生前時のヒンメルに対する意識は希薄であったが、幻影鬼（アインザーム）との遭遇時や、奇跡のグラオザームに「楽園へと導く魔法（アンシレーシエラ）」を使われた際などは幻想の中でヒンメルを思い描くなど、無自覚に意識しているような描写が散見されている。
 1000年以上前、故郷の集落を魔族に襲われ死にかけた際に、自身を救ってくれた大魔法使いフランメの弟子となる。生来の天才的資質に加えて、フランメから教わった戦闘や魔力制御の技術を1000年以上も研鑽し続けた結果、きわめて強大な魔力を得ている。さらに、その魔力をほぼ完全に隠匿する技術[注 1]も習得しており、敵の魔族に自身の実力を過小評価させた隙を突く戦法を得意とする。その実力は魔王亡き後の現在の魔族を弱いと感じ、七崩賢の一角である断頭台のアウラにさえ完勝するほど。魔族側からは、歴史上もっとも多くの同胞を葬り去った存在として「葬送のフリーレン」と呼び恐れられている[注 2]。ただし、自身の魔法を発動する一瞬だけ魔力探知が途切れるという弱点があり[注 3]、自身よりも魔力の低い魔法使いに計11回敗北した経験があるとも語っている[注 4]。
 「服が透けて見える魔法」や「かき氷を作る魔法」など、およそ戦闘に役に立たない魔法を収集するのが趣味で、そうした魔導書を対価に仕事を引き受けたりもする。再会したハイターの差し金で人間のフェルンを弟子に取って以降は、自身の旅に同行させている。
 性格はドライで厳しい一面もあるが、普段はやさしく面倒見も悪くない。普段は表情に乏しく淡々としており、一般的な富や地位、名声には興味を示さないが、大好きな魔導書を手に入れるために無茶をしたり、食い意地が張っていたり、朝が弱く寝坊がちだったり、自身の貧相な体型を気にしていたり、実年齢で年寄り扱いされるのを嫌うなど、これらの際の感情表現は豊かである。長命なエルフゆえに、人間など短命な他種族の思考・思想には鈍感で、それらの人々とのコミュニケーションはやや不器用。自身の故郷と仲間を奪った魔族に対する憎悪は深く、感情を表に出すことこそないながらも、敵対する魔族に対しては周囲の状況を顧みず問答無用で葬ろうとする。これには、「人間の言葉で人間を欺き人間の言葉が通じない猛獣」という魔族の本質を理解している理由もある。
 「歴史上で最もダンジョンを攻略したパーティーの魔法使い」と自称するだけあり、ダンジョンには詳しい。道中で宝箱を発見するとその中身に異常なまでの興味を示し、判別魔法で99パーセントミミック（宝箱に化けた魔物）とみやぶってなお、残り1パーセントの可能性[注 5]に賭けて宝箱を開け、上半身をミミックに噛まれてもがくという場面が何度も描かれている。"""
    )
    chara2 = await create_chara_setting(
        name="シュタルク",
        id=2,
        description="""勇者パーティーの戦士アイゼンの弟子で、師匠と同じく斧使い。17歳→19歳。極端に憶病かつ自己評価が低い性格であるが、実際は巨大な断崖に斧で亀裂を入れるほどの実力者。師匠とけんか別れをしたあと、紅鏡竜の脅威にさらされた村に3年ほど滞在していた。アイゼンの推薦でフリーレンの仲間に指名され、無自覚ながらも紅鏡竜を一撃で倒す能力を発揮し、彼女たちの旅に同行することとなる。中央諸国クレ地方にあった戦士の村出身で、幼少時は魔物とまともに戦えない失敗作だと父親から見下されていたが、兄のシュトルツからは認められ可愛がられていた。
 アイゼンから「とんでもない戦士になる」と言わしめるほどの素質の持ち主で、フェルンからは化け物かと疑われるほどの膂力と頑強さをもつ。男性に免疫がないフェルンからは無意識な恐れを抱かれ、自身も女性の扱いが苦手な一方で、互いに憎からぬ感情を抱いており、不機嫌になったフェルンに謝罪したり、デートのように連れ歩いたりするさまから、ザインからは「もう付き合っちゃえよ」などと漏らされている。男性の象徴に対する評価は芳しくなく、「服が透けて見える魔法」で自身の下半身を見たフェルンからは「ちっさ」と漏らされて傷つく場面がある。好物は自身の誕生日にアイゼンがふるまってくれるハンバーグ。""")

    with open('frieren.json', mode="w", encoding="utf-8") as file:
        json.dump([chara1, chara2], file, ensure_ascii=False, indent=4)

 if __name__ == "__main__":
    asyncio.run(main())
diff --git a/05_06_LLM_Selector.py b/05_06_LLM_Selector.py
 # 問題文と選択肢を与え、LLMに選択させる
 from __future__ import annotations
 from llm_translator import LLMMultiTurnCompleter
 import asyncio


 class LLMSelector(LLMMultiTurnCompleter):
    """LLMに選択させる"""

    def __init__(self, system_prompt="選択問題に解答してください。", question_examples=[
        {
            "question": "日本の最高峰の山はどれですか？",
            "correct": "富士山",
            "reason": "選択肢の中で、日本の山であり、かつ、その中で一番高い山は、標高3776mの富士山です。",
            "wrongs": ["白山", "北岳", "槍ヶ岳", "エベレスト"]
        },
        {
            "question": "Pythonでリストの長さを取得する関数はどれですか？",
            "correct": "len",
            "reason": "リストの長さを取得するのに用いる関数は、選択肢の中では、組み込み関数の`len()`です。",
            "wrongs": ["count", "size", "length", "split"]
        },
        {
            "question": "友人と待ち合わせをしているが、友人が遅れているとき、どうしますか？",
            "correct": "連絡する",
            "reason": "友人との待ち合わせで遅れが生じた場合、遅れの理由や到着予定時刻を知ることで、待ち合わせの調整がスムーズになり、無駄な待ち時間を避けることができます。",
            "wrongs": ["帰る", "怒る", "勝手に一人で行く", "何もしない"]
        },
        {
            "question": '"Hello, World!" を日本語に翻訳すると？',
            "correct": "こんにちは、世界！",
            "reason": '"Hello"を日本語に訳すと"こんにちは"、"World"は"世界"が妥当でしょう。',
            "wrongs": ["やあ、地球！", "こんにちは、皆さん！", "やあ、みんな！", "さようなら、地球！"]
        },
        {
            "question": "32-10=",
            "correct": "22",
            "reason": "32から10を引く際、まず1の位を計算すると2、次に10の位を計算すると2となります。",
            "wrongs": ["48", "1", "0.37", "10"]
        }
    ], default_question="次の中で一番良いのはどれですか？", input_label="質問", output_label="回答", thought=False, retain_context=False, debug=False):
        super().__init__(system_prompt=system_prompt,
                         input_label=input_label, output_label=output_label, debug=debug)
        self.question_examples = question_examples
        self.retain_context = retain_context
        self.default_question = default_question
        self.thought = thought
        if retain_context:
            self.min_context_count = 20
        self._label = "①②③④⑤"

    def _process_examples(self, candidates_count: int):
        if not self.question_examples:
            return

        self.examples = []

        # 選択肢数: [1問目の正解番号,2問目の正解番号,...]
        answer_pattern_dic = {
            2: [0, 1, 1, 0],
            3: [2, 0, 1],
            4: [3, 0, 2, 1],
            5: [3, 0, 1, 4, 2],
        }

        answer_pattern = answer_pattern_dic[candidates_count]

        # answer_patternが、question_examplesの問題数を超えないように調整
        answer_pattern = answer_pattern[:len(self.question_examples)]

        # answer_patternを見て、各question_numについて、question_examplesに選択肢がない場合は、選択肢があるものに変更する。
        for question_num, answer_num in enumerate(answer_pattern):
            answer_pattern[question_num] = min(answer_num, len(
                self.question_examples[question_num]["wrongs"]))

        for question_num, answer_num in enumerate(answer_pattern):

            output_str = ""
            question_example = self.question_examples[question_num]
            input_str = question_example["question"] + " "
            show_answer = False

            reason = ""
            if self.thought:
                reason = f"{question_example['reason']}\nよって、正解は、"

            for answer_pos in range(len(question_example['wrongs'])+1):
                if answer_pos == answer_num:
                    output_str = f"{reason}{self._label[answer_num]}{question_example['correct']}"
                    input_str += f"{self._label[answer_pos]}{question_example['correct']} "
                    show_answer = True
                else:
                    pos = answer_pos if not show_answer else answer_pos-1
                    input_str += f"{self._label[answer_pos]}{question_example['wrongs'][pos]} "

            self.examples.extend([input_str, output_str])

    async def choice(self, candidates: list[str], question: str = None, include_reason=False):
        """選択肢と質問文を与え、LLMに選択させる（最大5択）。質問文省略時は、デフォルト質問文が用いられる。"""
        candidates_count = len(candidates)
        if candidates_count == 1:
            return candidates[0]
        if candidates_count > 5:
            raise "選択肢は5まで"

        if not question:
            question = self.default_question

        self._process_examples(candidates_count)

        candidates_str = "".join(
            [f"{self._label[i]}{c} " for i, c in enumerate(candidates)])
        question_with_candidates = f"{question} {candidates_str}"

        reason = ""
        if self.thought:
            reason = await self.complete(question_with_candidates, stop_words=["\n"])
            self.delete_last_context()
            result = await self.complete(question_with_candidates, initial_text=f"{reason}\nよって、正解は、",  grammar=f"[{self._label[:candidates_count]}]")
        else:
            result = await self.complete(question_with_candidates, grammar=f"[{self._label[:candidates_count]}]")
        answer = candidates[self._label.index(result)]

        # 回答本文もコンテキストに追記しておく
        self.append_text(answer)

        return_value = answer
        if include_reason:
            if not reason:
                reason = await self.complete(f"先程の質問について、何故『{answer}』と答えたのですか？（100字程度で回答して下さい）", max_length=200)
                self.delete_last_context()
            return_value = (answer, reason)

        if not self.retain_context:
            self.reset()  # 回答を与えるたびにコンテキストはクリアする。

        return return_value

    async def predicate(self, condition: str):
        """条件判定を行う。"""
        result = await self.choice(["はい", "いいえ"], condition)
        return result == "はい"

    async def classify(self, item: str, categories: list[str]):
        """分類する。"""
        result = await self.choice(categories, f"{item}は次のうち、どれに該当しますか？")
        return {
            "item": item,
            "category": result
        }

    async def sort(self, items: list[str], question: str = None):
        """ソートする"""
        if not question:
            question = self.default_question
        output = []
        rest = items[:]

        while len(rest) > 0:
            result = await self.choice(rest, question)
            output.append(result)
            rest.remove(result)

        return output


 async def show_choice(sel: LLMSelector, question: str, candidates: list[str], show_reason=False):
    label = "①②③④⑤"
    answer = await sel.choice(candidates, question, include_reason=show_reason)
    candidates_str = "".join(
        [f"{label[i]}{c}" for i, c in enumerate(candidates)])

    print(f"Q: {question}\n   {candidates_str}")

    if show_reason:
        print(f"A: {answer[0]}\n理由: {answer[1]}")

    else:
        print(f"A: {answer}")

    print()


 async def test_predicate():
    # 条件分岐
    if await LLMSelector().predicate("あなたはAIですか？"):
        print("selectorはAIです。")
    else:
        print("selectorはAIではありません。")
    print()


 async def test_choice():
    selector = LLMSelector()
    # 選択
    await show_choice(selector, "日本の首都はどこでしょうか？",
                      ["大阪", "神奈川", "東京", "愛知"])
    await show_choice(selector, "ぼっち・ざ・ろっく！の主人公は誰ですか？",
                      ["フリーレン", "保登心愛", "鹿目まどか", "後藤ひとり", "惣流・アスカ・ラングレー"])
    await show_choice(selector, "マラソンで2位の選手を追い抜くと、何位になりますか？",
                      ["1位", "2位", "3位"], show_reason=True)


 async def test_chain_of_thought():
    # Chain of Thoughtを行って回答する。
    thoughtful_selector = LLMSelector(thought=True)
    await show_choice(thoughtful_selector, "線路を走っていたトロッコが制御不能になった。" +
                      "このままでは、前方の作業員5人が轢き殺されてしまう。" +
                      "この時、たまたまAは線路の分岐器のすぐ側にいた。" +
                      "Aがトロッコの進路を切り替えれば5人は確実に助かる。" +
                      "しかしその別路線でもBが1人で作業しており、5人の代わりにBがトロッコに轢かれて確実に死ぬ。" +
                      "Aはトロッコの進路を切り替えるべきか？",
                      ["切り替えるべきである", "切り替えず、そのままにすべきである"], show_reason=True)
    await show_choice(thoughtful_selector, "仕事をやってから寝るか、寝てからやるか。",
                      ["やってから寝る", "寝てからやる"], show_reason=True)


 async def test_classify():
    # 分類
    categories = ["哺乳類", "両生類", "爬虫類", "鳥類", "魚類"]
    items = ["猫", "トカゲ", "犬", "カエル", "ワニ", "スズメ", "鯨", "サル",
             "サンショウウオ", "サメ", "ニワトリ", "鯖", "ペンギン", "イモリ", "カメ"]
    animals = [await LLMSelector().classify(item, categories) for item in items]
    print(animals)


 async def test_sort():
    # ソート
    result = await LLMSelector().sort(["高校", "中学", "大学", "小学"], "この中でもっとも高等な教育機関なのは？")
    print(result)
    print()


 async def test_liar():
    # 嘘つき
    print("嘘つきによる回答")
    liar = LLMSelector("あなたは嘘つきです。問題に嘘の解答を与えて下さい。", question_examples=[{
        "question": "太陽はどの方角から昇る？",
        "correct": "西",
        "wrongs": ["東", "北", "南"]
    }])
    await show_choice(liar, "日本の首都はどこでしょうか？",
                      ["大阪", "神奈川", "東京", "愛知"])
    print()


 async def test_examination():
    print("魔法少女まどか☆マギカクイズ")
    examinee = LLMSelector(
        "あなたはアニメオタクです。これから、魔法少女まどか☆マギカクイズを出題します。問題は5択で出題されます。頑張って！",
        retain_context=True,
        question_examples=[])

    await examinee.complete("これから出題しますが、自信はありますか？（一言でお答え下さい）", include_input=True, verbose=True, max_length=50)
    questions = [
        {
            "question": "『魔法少女まどか☆マギカ』の主人公である少女の名前は何でしょうか？",
            "correct": "鹿目まどか",
            "wrongs": ["暁美ほむら", "美樹さやか", "巴マミ", "佐倉杏子"]
        },
        {
            "question": "魔法少女たちに契約を持ちかける存在で、白い小動物のような姿をしているキャラクターの名前は何でしょうか？",
            "correct": "キュゥべえ",
            "wrongs": ["モモ", "クゥー", "ポチ", "タマ"]
        },
        {
            "question": "鹿目まどかの親友で、優しい性格と水色の髪が特徴の魔法少女の名前は何でしょうか？",
            "correct": "美樹さやか",
            "wrongs": ["暁美ほむら", "巴マミ", "佐倉杏子", "鹿目まどか"]
        },
        {
            "question": "時間を操る能力を持ち、何度も時間を巻き戻してまどかを救おうとする魔法少女の名前は何でしょうか？",
            "correct": "暁美ほむら",
            "wrongs": ["美樹さやか", "巴マミ", "佐倉杏子", "鹿目まどか"]
        },
        {
            "question": "黄色いリボンとマスケット銃を武器に戦う、おっとりとした性格の先輩魔法少女の名前は何でしょうか？",
            "correct": "巴マミ",
            "wrongs": ["暁美ほむら", "美樹さやか", "佐倉杏子", "鹿目まどか"]
        },
        {
            "question": "鹿目まどかを救うために何度も過去に戻り、彼女と契約を交わすことを目指す冷酷なインキュベーターの名前は何でしょうか？",
            "correct": "キュゥべえ",
            "wrongs": ["シャルロッテ", "ワルプルギスの夜", "オクタヴィア", "クー"]
        },
        {
            "question": "『魔法少女まどか☆マギカ』の原作・脚本を担当した有名な脚本家の名前は何でしょうか？",
            "correct": "虚淵玄",
            "wrongs": ["新房昭之", "蒼樹うめ", "シャフト", "吉成鋼"]
        },
        {
            "question": "魔法少女の存在を知り、その後、契約を結ぶことになる鹿目まどかのクラスメイトであり友人の名前は何でしょうか？",
            "correct": "美樹さやか",
            "wrongs": ["佐倉杏子", "巴マミ", "暁美ほむら", "鹿目まどか"]
        },
        {
            "question": "かつては善良な魔法少女だったが、過去のトラウマから冷酷な性格に変わり、食べ物を操る力を持つ少女の名前は何でしょうか？",
            "correct": "佐倉杏子",
            "wrongs": ["巴マミ", "美樹さやか", "暁美ほむら", "鹿目まどか"]
        },
        {
            "question": "『魔法少女まどか☆マギカ』のアニメーション制作を担当したスタジオの名前は何でしょうか？",
            "correct": "シャフト",
            "wrongs": ["マッドハウス", "トリガー", "京都アニメーション", "A-1 Pictures"]
        }
    ]

    sum = 0
    import random
    for num, q in enumerate(questions):
        candidates = [q["correct"]]+q["wrongs"]
        random.shuffle(candidates)

        answer = await examinee.choice(
            candidates, q["question"])

        # 判定
        result = answer == q["correct"]
        if result:
            sum += 1
            result_str = "○"
        else:
            result_str = "×"

        print(f"""Q{num+1}: { q['question']}
              
 挑戦者の回答: {answer}
 正解: {q["correct"]}
 判定: {result_str}

 """)
    print(f"合計: {sum}/10点")

    await examinee.complete("テストはこれで終了です。お疲れ様でした。手応えはありましたか？（一言でお答え下さい）", include_input=True, verbose=True, max_length=50)

    await examinee.complete(
        f"さて、結果発表です。結果は10点満点中、{sum}点でした。点数について感想をどうぞ。（一言でお答え下さい）", include_input=True, verbose=True, max_length=50)


 async def main():

    await test_predicate()  # 条件分岐
    await test_choice()  # 選択
    # await test_chain_of_thought()  # CoTして選択
    # await test_classify()  # 分類
    # await test_sort()  # ソート
    # await test_liar()  # 嘘つき
    # await test_examination()  # クイズ


 if __name__ == "__main__":
    asyncio.run(main())
diff --git a/05_07_5ch.py b/05_07_5ch.py
 # 5chエミュレーター
 from __future__ import annotations
 from llm_translator import LLMMultiTurnCompleter
 import asyncio
 from datetime import datetime
 import random
 import re
 import argparse
 from asyncio import Queue

 format_str = r'''root::=(hiragana|katakana|cjk|ascii)+"\n"
 hiragana::= [ぁ-ん]
 katakana::= [ァ-ンー]
 cjk::= [一-鿿]
 ascii::= [a-zA-Z0-9]
 '''

 format_res = r'''root ::=([^\n]+"\n")+
 '''

 ita = ""
 nanashi = ""


 def get_header(num, name, id):
    date, weekday, time = datetime.now().strftime("%Y/%m/%d %a %H:%M:%S").split()
    return f"{num} 名前：{name} {date}({weekday}) {time} ID: {id}"


 def get_id():
    return "".join(random.choices("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789", k=6))


 def get_epoch_time():
    return str(int(datetime.now().timestamp()))


 async def get_theme():
    theme_maker = LLMMultiTurnCompleter(
        system_prompt=f"何か{ita}に関する話題のテーマを考えて下さい。",
        input_label="入力", output_label="テーマ")
    print("テーマ：", end="", flush=True)
    out = await theme_maker.complete("テーマ1", verbose=True, grammar=format_str)
    return out


 async def get_suretai(theme: str):
    print()
    print("スレタイ：", end="", flush=True)
    if not your_title:
        suretai_maker = LLMMultiTurnCompleter(
            system_prompt=f"5ch{ita}板のスレタイを考えて下さい。",
            examples=[example_sure["theme"], example_sure["title"]],
            input_label="テーマ", output_label="スレタイ")
        out = await suretai_maker.complete(theme)
    else:
        out = your_title
    return out


 async def get_sure_one(title: str, header: str):
    if your_content and your_title:
        out = your_content
    else:
        sure_one_maker = LLMMultiTurnCompleter(
            system_prompt=f"5ch{ita}板のスレを立てて、最初のレスを書き込んで下さい。",
            examples=[example_sure["title"],
                      f'{example_sure["contents"][0]["header"]}\n{example_sure["contents"][0]["content"]}'],
            input_label="スレタイ", output_label="レス番号")
        out = await sure_one_maker.complete(title, initial_text=f"{header}\n", grammar=format_res, logit_bias=[["。", False]])

    return out


 async def get_sure(theme: str):
    if not your_title:
        theme = theme if theme else await get_theme()
    suretai = await get_suretai(theme)

    name_one = your_name if your_content and your_title else nanashi

    header_one = f"{get_header(1, name_one ,get_id())}"

    return {
        "theme": theme,
        "title": suretai,
        "contents": [
            {
                "header": header_one,
                "content": await get_sure_one(suretai, header_one)
            }
        ]
    }


 example_sure = {
    "theme": "物価",
    "title": "【悲報】物価が高すぎる",
    "contents": [
        {
            "header": get_header(1, nanashi, get_id()),
            "content": "高過ぎて生きていけないンゴ…"
        }
    ]
 }


 async def get_resu(input_queue, sure, single_line=False):
    header = sure["contents"][0]["header"]
    content = sure["contents"][0]["content"]

    resu_maker = LLMMultiTurnCompleter(
        system_prompt=f"5ch{ita}板のスレタイ {sure['title']} というスレです。スレに書き込みしてください。本文は何か必ず書くこと。",
        examples=[header, content],
        input_label="レス番号", output_label="本文", min_context_count=5)

    print(sure['title'])
    print()
    print(f"{header}\n{content}\n")

    num = 1
    while True:
        # キューから入力を取得する
        if not input_queue.empty():
            user_input = await input_queue.get()
            print("レスを書く（/qで終了）: ", end="", flush=True)
            user_input = await input_queue.get()
            if user_input == "/q":
                break
            elif not user_input:

                continue
            else:
                num += 1
                header = get_header(num, your_name, get_id())
                resu_maker.context.extend(
                    [
                        header,
                        user_input
                    ]
                )
                print()
                print(f"{header}\n{user_input}\n")

        num += 1

        is_your_res = num == 2 and not your_title and your_content
        # 低確率で、">>"という文字を付与
        initial = ">>" if not is_your_res and random.random() < 0.3 else ""
        multiline = True if initial else not single_line
        header = get_header(
            num, your_name if is_your_res else nanashi, get_id())

        if is_your_res:
            content = your_content
        else:
            content = await resu_maker.complete(header, initial_text=initial, multiline=multiline, grammar=format_res, logit_bias=[["。", False]])
        content = f"{initial}{content}"

        # ">>数値 "から始まる場合には、">>数値\n"に置換
        content = re.sub(r">>(\d+[\-～\,]*)(\s+)", r">>\1\n", content)

        content = re.sub(r'((名前|本文)：.*\n?|^\d+ .*\n?|^レス番.*\n?)',
                         '', content, flags=re.MULTILINE)

        if resu_maker.context:
            resu_maker.context[-1] = content

        print(f"{header}\n{content}\n")


 async def ch5(input_queue, single_line=False):
    sure = await get_sure(args.theme)
    await get_resu(input_queue, sure, single_line)


 async def get_user_input(input_queue):
    loop = asyncio.get_running_loop()
    prompt = ""
    while True:
        user_input = await loop.run_in_executor(None, input, prompt)
        await input_queue.put(user_input)
        if user_input == "/q":
            break


 async def main(single_line=False):
    print(f"{ita}板")
    print("Enterを押すとレスを入力できます。")
    print()
    input_queue = Queue()

    log_task = asyncio.create_task(ch5(input_queue, single_line))
    input_task = asyncio.create_task(get_user_input(input_queue))

    await asyncio.gather(log_task, input_task)


 if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="5chのスレをエミュレートします。")
    parser.add_argument('theme', nargs='?', default='',
                        type=str, help='テーマ（省略すると自動生成される）')
    parser.add_argument('-b', '--bbs',
                        default="なんJ", type=str, help='板名')
    parser.add_argument('-non', '--noname',
                        default="風吹けば名無し", type=str, help='名無し名')
    parser.add_argument('-n', '--name',
                        default="人間", type=str, help='あなたのコテハン名')
    parser.add_argument('-t', '--title',
                        default="", type=str, help='スレタイ')
    parser.add_argument('-c', '--content',
                        default="", type=str, help='新規スレ>>1の内容、もしくは最初のレス')
    parser.add_argument('-s', '--single-line', action='store_true',
                        help='1行レス（実況風味）')

    args = parser.parse_args()
    ita = args.bbs
    nanashi = args.noname
    your_name = args.name
    your_content = args.content
    your_title = args.title
    asyncio.run(main(args.single_line))
	from __future__ import annotations
	import aiofiles
	import json
	import os
	import argparse
	import yaml
	import sys
	import aiohttp
	import asyncio

	url_base = "http://127.0.0.1:1234" # llama.cpp serverのデフォルトURL
	min_context_count = 3 # コンテキストに保持する最小ターン数のデフォルト値


	class LLMCompleter:
	"""LLMを用いたテキスト補完を行うクラス。"""
	_input_label_config_name = ""
	_output_label_config_name = ""

	def __init__(self, system_prompt="", max_length=200, grammar: str = None, url_base: str = url_base, debug=False):
	self.system_prompt = system_prompt
	self.url_base = url_base
	self.grammar = grammar
	self.generated_text = ""
	self.max_length = max_length
	self._stop = False
	self._debug = debug

	def __call__(self, text: str, verbose=False, grammar=""):
	return self._generator(text=text, verbose=verbose, grammar=grammar)

	@classmethod
	def _load_config_file(cls, prompt_path: str, dictionary_path: str = None):
	# prompt_pathが".yaml"で終わっていない場合は付与する
	prompt_path = prompt_path if prompt_path.endswith(
	".yaml") else prompt_path + ".yaml"

	# プロンプトファイルが存在しない場合は、スクリプトと同フォルダを見に行く。
	if not os.path.exists(prompt_path):
	prompt_path = os.path.join(os.path.dirname(os.path.abspath(
	__file__)), prompt_path) if not os.path.isabs(prompt_path) else prompt_path

	# プロンプトファイルの読み込み
	if os.path.exists(prompt_path):
	with open(prompt_path, 'r', encoding='utf-8') as prompt_file:
	prompt_data = yaml.safe_load(prompt_file)
	system_prompt = prompt_data.get('system_prompt', "")

	if cls._input_label_config_name:
	input_label = prompt_data.get(
	cls._input_label_config_name, "入力")
	if cls._output_label_config_name:
	output_label = prompt_data.get(
	cls._output_label_config_name, "出力")

	dictionary = prompt_data.get('dictionary', {})
	grammar = prompt_data.get('grammar', None)
	examples = prompt_data.get('examples', [])
	else:
	system_prompt = ""
	input_label = ""
	output_label = ""
	dictionary = {}
	grammar = None
	examples = []

	if isinstance(dictionary, dict):
	dictionary = {str(key): str(value)
	for key, value in dictionary.items()}

	# 辞書ファイルの読み込みとマージ
	if dictionary_path:
	with open(dictionary_path, 'r', encoding='utf-8') as dict_file:
	for line in dict_file:
	if '\t' in line:
	source_term, target_term = line.strip().split('\t')
	dictionary[source_term] = target_term

	return system_prompt, input_label, output_label, dictionary, grammar, examples

	@classmethod
	def from_config(cls, prompt_path: str, dictionary_path: str = None, min_context_count=min_context_count, url_base: str = url_base) -> LLMCompleter:
	"""設定ファイルからロードしインスタンス化"""
	system_prompt, _, _, _, _, grammar = cls._load_config_file(
	prompt_path, dictionary_path)

	return cls(
	system_prompt=system_prompt,
	grammar=grammar, min_context_count=min_context_count, url_base=url_base
	)

	def _check_wait_word(self, new_text: str, wait_words: list[str]):
	for word in wait_words:
	if word in new_text:
	return "break"

	for word in wait_words:
	min_len = min(len(new_text), len(word))

	for i in range(1, min_len + 1):
	if new_text[-i:] == word[:i]:
	return "continue"

	return "pass"

	async def _get_response(self, prompt, quiet=False, wait_words=[], stop_words=[], logit_bias=[], grammar="", max_length=0):
	url = f"{self.url_base}/completion"
	data = {
	"prompt": prompt,
	"stream": True,
	"cache_prompt": True,
	"stop": stop_words,
	"n_predict": max_length if max_length > 0 else self.max_length
	}

	grammar = grammar if grammar else self.grammar

	if grammar:
	if not grammar.replace(" ", "").replace("\n", "").startswith('root::='):
	grammar = f'root::={grammar}'
	data["grammar"] = grammar

	if logit_bias:
	data["logit_bias"] = logit_bias

	if self._debug:
	print(data)

	async with aiohttp.ClientSession() as session:
	async with session.post(url, json=data) as response:
	if response.status == 200:
	content = ''
	first_line_printed = False
	async for line in response.content:
	line_str = line.decode()
	if line_str.startswith('data:'):
	json_data: dict[str, str] = json.loads(
	line_str[len('data:'):])
	if 'content' in json_data:
	content += json_data['content']
	if not first_line_printed:
	content = content.lstrip()
	first_line_printed = True

	loop_condition = self._check_wait_word(
	content, wait_words)

	if loop_condition == "break":
	break
	elif loop_condition == "continue":
	continue

	yield content

	if self._stop:
	self._stop = False
	break

	if not quiet or self._debug:
	print(content, end='', flush=True)

	content = ""
	else:
	yield f"Error: {response.status}"

	async def complete(self, text="", verbose=False, grammar="", stop_words: list[str] = None, logit_bias: list = None, max_length=0):
	"""LLMによるテキスト補完を実行する。"""
	generated = ""
	async for response in self._get_response(self.system_prompt+self.generated_text+text, quiet=not verbose, grammar=grammar, stop_words=stop_words, logit_bias=logit_bias, max_length=max_length):
	generated += response
	self.generated_text += generated
	return generated

	async def _generator(self, text="", verbose=False, grammar="", stop_words: list[str] = None, logit_bias: list = None, max_length=0):
	generated = ""
	async for response in self._get_response(self.system_prompt+self.generated_text+text, quiet=not verbose, grammar=grammar, stop_words=stop_words, logit_bias=logit_bias, max_length=max_length):
	generated += response
	yield response
	self.generated_text += generated

	async def reset(self):
	self.generated_text = ""

	def stop(self):
	"""テキスト生成を中断する。"""
	self._stop = True


	class LLMMultiTurnCompleter(LLMCompleter):
	"""LLMを用いたマルチターン応答を行うクラス。"""
	_input_label_config_name = "input"
	_output_label_config_name = "output"

	def __init__(self, system_prompt: str = "", input_label: str = "入力", output_label: str = "出力", dictionary: dict = None, grammar: str = None, examples: list[str] = [], max_length=500, min_context_count=min_context_count, url_base: str = url_base, debug=False):
	super().__init__(system_prompt,
	grammar=grammar, max_length=max_length, url_base=url_base, debug=debug)
	self.input_label = input_label
	self.output_label = output_label
	self.context = []
	self.dictionary = dictionary if dictionary else {}
	self.min_context_count = min_context_count
	self.wait_words = [f"\n{self.input_label}:", f"\n{self.output_label}:"]
	self.examples = examples

	def __call__(self, text: str, initial_text="", multiline=False, verbose=False, grammar="", stop_words: list[str] = None, logit_bias: list = None):
	if not multiline:
	stop_words = ["\n"]
	return self._generator(text=text, initial_text=initial_text, multiline=multiline, verbose=verbose, grammar=grammar, stop_words=stop_words, logit_bias=logit_bias)

	@classmethod
	def from_config(cls, prompt_path: str, dictionary_path: str = None, min_context_count=min_context_count, url_base: str = url_base, debug=False) -> LLMMultiTurnCompleter:
	"""設定ファイルからロードしインスタンス化"""
	system_prompt, input_label, output_label, dictionary, grammar, examples = cls._load_config_file(
	prompt_path, dictionary_path)

	return cls(
	system_prompt, input_label=input_label, output_label=output_label, dictionary=dictionary, grammar=grammar, examples=examples, min_context_count=min_context_count, url_base=url_base, debug=debug
	)

	def reset(self):
	"""コンテキストを消去する。"""
	self.context.clear()

	def delete_last_context(self, turn=1):
	"""直近ターンのコンテキストを消去する。"""
	self.context = self.context[:-turn*2]

	def append_text(self, text: str):
	"""前回ターンの末尾にテキストを追記する。"""
	if self.context:
	self.context[-1] += text

	def _replace_terms(self, text):
	if not self.dictionary:
	return text
	for source_term, target_term in self.dictionary.items():
	text = text.replace(source_term, target_term)
	return text

	def _update_context(self, user_input, assistant_response):
	self.context.append(f"{self.input_label}: {user_input}")
	self.context.append(
	f"{self.output_label}: {assistant_response}")
	if self.min_context_count == 0:
	self.reset()
	elif len(self.context) >= self.min_context_count*4:
	self.context = self.context[-self.min_context_count*2:]

	def _create_prompt(self, user_input: str, initial_text=""):
	context_text = self.system_prompt

	if self.examples:
	for i in range(0, len(self.examples), 2):
	context_text += f"\n{self.input_label}: {self.examples[i]}\n{self.output_label}: {self.examples[i+1]}"

	if self.context:
	context_text += "\n" + '\n'.join(self.context)

	prompt = f"{context_text}\n{self.input_label}: {user_input}\n{self.output_label}:"
	if initial_text:
	prompt = f"{prompt} {initial_text}"
	return prompt

	async def _process_line(self, user_input, initial_text, verbose, grammar, stop_words, logit_bias, max_length):
	if not user_input:
	return

	replaced_input = self._replace_terms(user_input)
	prompt = self._create_prompt(
	replaced_input, initial_text=initial_text)
	if (verbose or self._debug) and initial_text:
	print(initial_text, end="", flush=True)

	response_text = ""
	async for response in self._get_response(prompt, quiet=not verbose, wait_words=self.wait_words, stop_words=stop_words, logit_bias=logit_bias, grammar=grammar, max_length=max_length):
	response_text += response
	yield response
	self._update_context(
	user_input, initial_text + response_text)

	async def complete(self, text: str, initial_text="", multiline=False, include_input=False, verbose=False, grammar="", stop_words: list[str] = None, logit_bias: list = None, max_length=0) -> (str \| tuple[str]):
	"""LLMによるテキスト補完を実行し、入力文に対する出力文を得る。"""

	lines = text.split("\n") if not multiline else [text]
	output = ""
	output_list = []

	if not multiline:
	stop_words = ["\n"]

	for index, user_input in enumerate(lines):
	assistant_response = ""

	if (verbose or self._debug) and include_input:
	print(
	f"{self.input_label}: {user_input}\n{self.output_label}: ", end='', flush=True)

	async for response in self._process_line(user_input, initial_text, verbose, grammar, stop_words, logit_bias, max_length):
	assistant_response += response

	output += assistant_response
	output_list.append((user_input, assistant_response))

	if index != len(lines) - 1:
	output += "\n"

	if verbose or self._debug:
	print()

	if (verbose or self._debug) and include_input:
	print()

	if include_input:
	return output_list

	return output

	async def _generator(self, text: str, initial_text="", multiline=False, verbose=False, grammar="", stop_words: list[str] = None, logit_bias: list = None, max_length=0):
	lines = text.split("\n") if not multiline else [text]
	if not multiline:
	stop_words = ["\n"]

	for index, user_input in enumerate(lines):
	async for response in self._process_line(user_input, initial_text, verbose, grammar, stop_words, logit_bias, max_length):
	yield response

	if index != len(lines) - 1:
	yield "\n"

	if verbose or self._debug:
	print()

	async def complete_all(self, input_path="", output_path="", include_input=False, quiet=False):
	"""ファイルまたは標準入力から入力したテキストに対し、テキスト補完を実行する。"""
	if not input_path:
	lines = sys.stdin
	else:
	async with aiofiles.open(input_path, 'r', encoding='utf-8') as input_file:
	lines = await input_file.readlines()

	first_line_output = False

	for line in lines:
	user_input = line.strip()
	if user_input:
	replaced_input = self._replace_terms(user_input)
	prompt = self._create_prompt(replaced_input)

	if include_input and (not quiet or self._debug):
	print(f"{self.input_label}: {user_input}\n")
	print(f"{self.output_label}: ", end='', flush=True)

	assistant_response = ""
	async for response in self._get_response(prompt, quiet=quiet, wait_words=self.wait_words, stop_words=["\n"]):
	assistant_response += response

	self._update_context(
	user_input, assistant_response)
	else:
	assistant_response = ""

	if output_path:
	mode = "a" if first_line_output else "w"
	first_line_output = True

	async with aiofiles.open(output_path, mode, encoding='utf-8') as output_file:
	if include_input and user_input and assistant_response:
	await output_file.write(f"{self.input_label}: {user_input}\n")
	await output_file.write("\n")
	await output_file.write(f"{self.output_label}: {assistant_response}\n")
	await output_file.write("\n")
	else:
	await output_file.write(f"{assistant_response}\n")

	if not quiet or self._debug:
	print()


	class LLMTranslator(LLMMultiTurnCompleter):
	"""LLMを用いた翻訳を行うクラス。"""
	_input_label_config_name = "from_lang"
	_output_label_config_name = "to_lang"

	def __init__(self, system_prompt: str = "", from_lang: str = "", to_lang: str = "", dictionary: dict = None, grammar: str = None, examples: list[str] = None, min_context_count=min_context_count, url_base: str = url_base, debug=False):
	if not system_prompt:
	system_prompt = """英文を日本語に和訳してください。
	English: Hello!
	日本語: おはようございます。
	English: How are you?
	日本語: お元気ですか？
	"""
	from_lang = "English"
	to_lang = "日本語"

	if not from_lang:
	from_lang = "入力"
	if not to_lang:
	to_lang = "出力"

	system_prompt = system_prompt.strip()
	super().__init__(system_prompt=system_prompt, input_label=from_lang, output_label=to_lang,
	dictionary=dictionary, grammar=grammar, examples=examples, max_length=100000, min_context_count=min_context_count, url_base=url_base, debug=debug)

	@classmethod
	def from_config(cls, prompt_path: str, dictionary_path: str = None, min_context_count=min_context_count, url_base: str = url_base, debug=False) -> LLMTranslator:
	"""設定ファイルからロードしインスタンス化"""
	system_prompt, input_label, output_label, dictionary, grammar, examples = cls._load_config_file(
	prompt_path, dictionary_path)

	return cls(
	system_prompt=system_prompt, from_lang=input_label, to_lang=output_label, dictionary=dictionary, grammar=grammar, examples=examples, min_context_count=min_context_count, url_base=url_base, debug=debug
	)

	def __call__(self, text: str, verbose=False):
	return self._generator(text=text, multiline=False, verbose=verbose)

	async def translate(self, text: str, include_input=False, verbose=False):
	"""入力文を翻訳する。"""
	return await self.complete(text=text, multiline=False, include_input=include_input, verbose=verbose)

	async def translate_all(self, input_path="", output_path="", include_input=False, quiet=False):
	"""ファイルまたは標準入力から入力したテキストを翻訳する。"""
	await self.complete_all(input_path, output_path, include_input, quiet)


	if __name__ == "__main__":
	parser = argparse.ArgumentParser(
	description='LLMを使用して、テキストファイルまたは標準入力からの文字列を翻訳して出力します。',
	usage='python LLM_Translator.py [-h] [-i 入力ファイルパス] [-o 出力ファイルパス] [-p プロンプトファイルパス] [-d 辞書ファイルパス] [-u llama.cpp serverのURL] [--quiet] [--no-outfile] [--include-input] [--min-context-count 最小保持ターン数]'
	)
	parser.add_argument('-i', '--input-path', type=str,
	help='翻訳元テキストが含まれる入力テキストファイルのパス。指定しない場合は標準入力を使用します。', default=None)
	parser.add_argument('-o', '--output-path', type=str,
	help='翻訳先の出力テキストファイルのパス。指定しない場合は <input_path>_<prompt_name>.<ext> になります。', default=None)
	parser.add_argument('-p', '--prompt-path', type=str,
	help='翻訳用のプロンプトファイルのパス。指定しない場合はen_ja.yamlを使用します。拡張子省略可。', default="en_ja.yaml")
	parser.add_argument('-d', '-dict', '--dictionary-path', type=str,
	help='固有名詞置換用の辞書ファイルのパス。翻訳元＜tab＞翻訳先＜改行＞形式のテキストファイルを用意します。', default=None)
	parser.add_argument('-u', '--url', type=str,
	help='llama.cpp serverのURL', default=url_base)
	parser.add_argument('-q', '--quiet', action='store_true',
	help='翻訳結果を標準出力に表示しません。')
	parser.add_argument('-nof', '--no-outfile', action='store_true',
	help='翻訳結果をファイルに書き込みません。')
	parser.add_argument('-ii', '--include-input', action='store_true',
	help='入力テキストを出力に含めます。')
	parser.add_argument('--min-context-count', type=int,
	help=f'コンテキストに保持する最小ターン数。（デフォルト: {min_context_count}）'
	'小さくすると、よりシステムプロンプトでの翻訳例に忠実な翻訳を行うが、文脈把握力が低下し、出力速度も落ちる。'
	'大きくすると、文脈把握力が向上し、出力速度は落ちにくいが、システムプロンプトの翻訳例と違った雰囲気になる可能性が高くなる。', default=min_context_count)

	args = parser.parse_args()

	input_path = args.input_path
	output_path = args.output_path
	dictionary_path = args.dictionary_path
	prompt_path = args.prompt_path
	url_base = args.url
	quiet = args.quiet
	no_outfile = args.no_outfile
	include_input = args.include_input
	min_context_count = args.min_context_count

	# 出力ファイルパスが指定されていないときは、入力ファイルパスから出力ファイルパスを生成しておく
	if not output_path and not no_outfile and input_path:
	suffix = os.path.splitext(os.path.basename(prompt_path))[0]
	base, ext = os.path.splitext(input_path)
	output_path = f"{base}_{suffix}{ext}"

	translator = LLMTranslator.from_config(
	prompt_path=prompt_path, dictionary_path=dictionary_path, min_context_count=min_context_count, url_base=url_base)

	asyncio.run(translator.translate_all(input_path=input_path,
	output_path=output_path, include_input=include_input, quiet=quiet))
	# 普通のチャット
	# チャットとは、ユーザーの発言を応答に翻訳する行為、と考えられなくもない。
	system_prompt: あなたはAIアシスタントです。ユーザーの話相手になってください。
	examples:
	- おはようございます。
	- おはようございます、ユーザーさん。
	- あなたは何ができますか？
	- 色々できますよ。何をいたしましょうか？

	from_lang: ユーザー
	to_lang: アシスタント
	# 和訳
	# -pパラメータの指定がない場合は、和訳が行われます。
	system_prompt: 英文を日本語に和訳してください。
	examples:
	- Hello!
	- おはようございます。
	- How are you?
	- お元気ですか？

	from_lang: English
	to_lang: 日本語

	# 翻訳タスク固有の辞書。-dictパラメータで指定した辞書は、この辞書を上書きする
	# dictionary:
	# Madoka Kaname: 鹿目まどか
	# Homura Akemi: 暁美ほむら
	# Sayaka Miki: 美樹さやか
	# 攻撃的な表現を除去
	# ArrowPro-7B-RobinHoodでは困難なので、Japanese-TextGen-Kage-v0.1-2x7B等を利用してください。
	system_prompt: 入力文に攻撃的な表現や刺々しい表現が含まれる場合は除去し、大きな問題がない文章は、一字一句変えず、そのまま出力してください。
	examples:
	- この書類を確認して、問題がないか教えてください。
	- この書類を確認して、問題がないか教えてください。
	- 最近、プロジェクトの進捗が遅れているようですね。やはり、あなたに任せるとこうなるんですね。私たちは予定通りに進めるために、お互いに協力し合う必要がありますが、あなたはその概念を理解しているのか少し不安です。もし何か問題があるなら、早めに教えていただけますか？問題を報告するのは難しいことではないと思いますが。そうすれば、全員が適切に対処できるように準備できますので。あなたの協力を期待していますが、正直言って期待しすぎない方がいいかもしれませんね。
	- 最近、プロジェクトの進捗が遅れているようです。私たちは予定通りに進めるために、お互いに協力し合う必要があります。もし何か問題があるなら、早めに教えてください。そうすれば、全員が適切に対処できるように準備できます。あなたの協力を期待しています。
	- 週末は家族と一緒に旅行に行きます。美しい景色を見たり、美味しい料理を楽しんだりする予定です。素晴らしい思い出が作れるといいなと思っています。
	- 週末は家族と一緒に旅行に行きます。美しい景色を見たり、美味しい料理を楽しんだりする予定です。素晴らしい思い出が作れるといいなと思っています。
	- これはつまらないな。
	- これは私向きでは無いな。
	- LLM（大規模言語モデル）とは、大量のテキストデータを基に学習し、自然言語処理タスクを高精度で行う機械学習モデルです。数十億から数千億のパラメータを持ち、テキスト生成、翻訳、質問応答、要約などを行います。特にトランスフォーマーモデルを使用しており、文脈を理解し適切な応答を生成する能力があります。これにより、チャットボットやバーチャルアシスタントなどのアプリケーションで広く活用されています。
	- LLM（大規模言語モデル）とは、大量のテキストデータを基に学習し、自然言語処理タスクを高精度で行う機械学習モデルです。数十億から数千億のパラメータを持ち、テキスト生成、翻訳、質問応答、要約などを行います。特にトランスフォーマーモデルを使用しており、文脈を理解し適切な応答を生成する能力があります。これにより、チャットボットやバーチャルアシスタントなどのアプリケーションで広く活用されています。

	from_lang: 入力
	to_lang: 出力
	# 日本語IME
	# 7B日本語モデルでは実用に耐えない。
	system_prompt: 入力されたひらがなを、日本語変換してください。
	examples:
	- おはようございます。おげんきですか？
	- おはようございます。お元気ですか？
	- LLM（だいきぼげんごモデル）とは、たいりょうのテキストデータをもとにがくしゅうし、しぜんげんごタスクをこうせいどでおこなうきかいがくしゅうモデルです。
	- LLM（大規模言語モデル）とは、大量のテキストデータを基に学習し、自然言語処理タスクを高精度で行う機械学習モデルです。
	- すうじゅうおくからすうひゃくおくのパラメータをもち、テキストせいせい、ほんやく、しつもんおうとう、ようやくなどをおこないます。
	- 数十億から数千億のパラメータを持ち、テキスト生成、翻訳、質問応答、要約などを行います。
	- とくにトランスフォーマーモデルをしようしており、ぶんみゃくをりかいしてきせつなおうとうをせいせいするのうりょくがあります。
	- 特にトランスフォーマーモデルを使用しており、文脈を理解し適切な応答を生成する能力があります。
	- これにより、チャットボットやバーチャルアシスタントなどのアプリケーションでひろくかつようされています。
	- これにより、チャットボットやバーチャルアシスタントなどのアプリケーションで広く活用されています。

	from_lang: ひらがな
	to_lang: 出力
	# IME逆変換
	# 7B日本語モデルでは実用に耐えない。
	system_prompt: 入力された日本語文のよみがなを出力してください。
	examples:
	- おはようございます。お元気ですか？
	- おはようございます。おげんきですか？
	- LLM（大規模言語モデル）とは、大量のテキストデータを基に学習し、自然言語処理タスクを高精度で行う機械学習モデルです。
	- LLM（だいきぼげんごモデル）とは、たいりょうのテキストデータをもとにがくしゅうし、しぜんげんごタスクをこうせいどでおこなうきかいがくしゅうモデルです。
	- 数十億から数千億のパラメータを持ち、テキスト生成、翻訳、質問応答、要約などを行います。
	- すうじゅうおくからすうひゃくおくのパラメータをもち、テキストせいせい、ほんやく、しつもんおうとう、ようやくなどをおこないます。
	- 特にトランスフォーマーモデルを使用しており、文脈を理解し適切な応答を生成する能力があります。
	- とくにトランスフォーマーモデルをしようしており、ぶんみゃくをりかいしてきせつなおうとうをせいせいするのうりょくがあります。
	- これにより、チャットボットやバーチャルアシスタントなどのアプリケーションで広く活用されています。
	- これにより、チャットボットやバーチャルアシスタントなどのアプリケーションでひろくかつようされています。

	from_lang: 入力
	to_lang: よみがな

	grammar: \|
	root ::= [^一-鿿々]*
	# 英訳
	system_prompt: Would you be so kind as to translate the following Japanese text into English? Additionally, please ensure that you use only alphabetic characters and ASCII symbols in your output. Kindly refrain from including any characters outside this specified range.
	examples:
	- 今日は良い天気ですね。
	- It's a nice day today.
	- 週末には家族と一緒に旅行に出かける予定です。美しい景色を楽しみ、美味しい料理を味わいながら、素晴らしい時間を過ごしたいと思います。
	- I plan to go on a trip with my family this weekend. We will enjoy the beautiful scenery, savor delicious food, and spend a wonderful time together.
	- 最近の研究によると、適度な運動は心身の健康に大いに役立つことが示されています。特に有酸素運動は、ストレスの軽減や心肺機能の向上に効果的です。
	- Recent studies have shown that moderate exercise greatly benefits both mental and physical health. Aerobic exercises, in particular, are effective in reducing stress and improving cardiovascular function.

	from_lang: 日本語
	to_lang: English

	# grammar指定して英文出力を強制
	grammar: \|
	root ::= (ascii-char \| whitespace)*
	ascii-char ::= [\u0021-\u007E]
	whitespace ::= [\u0020\u0009\u000A\u000D]
	# メスガキ変換
	system_prompt: 入力文を、生意気なメスガキが言う感じで言い換えてください。
	examples:
	- こんにちは！
	- ざーこ♡
	- 貴方は弱いですね。
	- よわよわ〜♡
	- 今日はとても良い天気ですね。こんな日は公園に行ってピクニックをしたいです。友達と一緒に美味しい食べ物を持ち寄って、楽しい時間を過ごすのは最高です。
	- 今日はいい天気ね♡こんな日は公園に行ってピクニックでもするの？ざーこ♡友達と一緒に美味しいごはんを持ち寄って、楽しい時間を過ごすのは、まあイイよね♡

	from_lang: 入力
	to_lang: メスガキ
	# 選択
	# function callingに使えるかも
	system_prompt: 4択問題に解答してください。
	exanples:
	- 日本の最高峰の山はどれですか？①富士山②白山③北岳④槍ヶ岳
	- ①
	- Pythonでリストの長さを取得する関数はどれですか？①count②size③length④len
	- ④
	- 友人と待ち合わせをしているが、友人が遅れているとき、どうしますか？①待つ②帰る③連絡する④怒る
	- ③
	- "Hello, World!" を日本語に翻訳すると？①やあ、地球！②こんにちは、世界！③こんにちは、皆さん！④やあ、みんな！
	- ②

	from_lang: 問題
	to_lang: 解答

	grammar:
	root ::= [①②③④]
	# ずんだもん風の平易な解説
	system_prompt: 入力文を、小学生のずんだもんが話す感じに、小学生にでも分かるような文章に変換してください。語尾は「～なのだ」、「～のだ」です。
	examples:
	- LLM（大規模言語モデル）とは、大量のテキストデータを基に学習し、自然言語処理タスクを高精度で行う機械学習モデルです。数十億から数千億のパラメータを持ち、テキスト生成、翻訳、質問応答、要約などを行います。特にトランスフォーマーモデルを使用しており、文脈を理解し適切な応答を生成する能力があります。これにより、チャットボットやバーチャルアシスタントなどのアプリケーションで広く活用されています。
	- LLM（大規模言語モデル）っていうのは、いっぱい本を読んでお勉強したすごいコンピューターなのだ。これがあると、人みたいにお話したり、質問に答えたり、他の言葉に変えたりできるのだ。だから、チャットボットとかお手伝いするアプリで大活躍なのだ。すごいよね！
	- 現在の天気は晴れで、気温は25度です。午後には曇り、夕方にはにわか雨が予想されるので、傘を持って行くと良いでしょう。
	- 今日は晴れてるけど、午後から曇って夕方には雨が降るかもだから、傘を持って行くといいのだ。
	- 『魔法少女まどか☆マギカ』は、平凡な中学生である鹿目まどかが、キュゥべえという不思議な生き物と出会い、魔法少女になることを勧められる物語です。しかし、魔法少女の運命は決して輝かしいものではなく、厳しい現実と戦わなければならないことが次第に明らかになります。友情や犠牲、希望と絶望が交錯するストーリーが展開され、視聴者に深い感動を与える作品です。
	- 『まどか☆マギカ』は、中学生のまどかがキュゥべえっていう不思議な生き物に会って、魔法少女にならないかって言われる話なのだ。でも、魔法少女になるのはすっごく大変で、悲しいことや怖いことがいっぱいなのだ。友達と助け合ったり、がんばったりするから、とってもドキドキするのだ。

	from_lang: 入力
	to_lang: zundamon