Upload 53 files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+asset/external_view.pptx filter=lfs diff=lfs merge=lfs -text

README.md

@@ -1,10 +1,26 @@
----
-title: Neo Llm Module V1.3.5
-emoji: 🐢
-colorFrom: pink
-colorTo: blue
-sdk: static
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# neoLLM Module
+
+neoAIのLLMソリューションの基盤モジュール
+[neoLLM Module Document](https://www.notion.so/neoLLM-Module-Document-64399d1d1db24d92bce8f9b88472833f)
+
+## 準備
+[neoLLM インストール方法](https://www.notion.so/c760d96f1b4240e6880a32bee96bba35)
+1. install neoLLM Module ※ Python 3.10
+   ```bash
+   $ pip install git+https://github.com/neoAI-inc/neo-llm-module.git@v1.x.x
+   ```
+
+2. APIキーの設定
+   `.env`ファイルの配置
+   - 環境変数を`.env`ファイルで定義し，実行するバスに配置
+   - `project/example_env.txt`を`.env`に名前を変えて, 必要事項を記入
+
+## 使用方法
+### 概要
+灰色背景の部分を開発するだけでOK
+- MyLLM: 1回のLLMへのリクエストをラップできる
+- MyL3M2: 複数のLLMへのリクエストをラップできる
+
+詳しくは、`project/neollm-tutorial.ipynb`, `project/ex_module`
+![外観図](asset/external_view.png)
+

asset/external_view.pptx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7b3e9d7dbbb6f9ca5750edd9eaad8fe7ce5fcb5797e8027ae11dea90a0a47a2c
+size 8728033

makefile

@@ -0,0 +1,14 @@
+.PHONY: lint
+lint: ## run tests with poetry (isort, black, pflake8, mypy)
+	poetry run black neollm
+	poetry run isort neollm
+	poetry run pflake8 neollm
+	poetry run mypy neollm --explicit-package-bases
+
+.PHONY: test
+test:
+	poetry run pytest
+
+.PHONY: unit-test
+unit-test:
+	poetry run pytest -k "not test_neollm"

neollm.code-workspace

@@ -0,0 +1,63 @@
+{
+  "folders": [
+    {
+      "name": "neo-llm-module",
+      "path": "."
+    }
+  ],
+  "settings": {
+    "editor.codeActionsOnSave": {
+      "source.fixAll.eslint": "explicit",
+      "source.fixAll.stylelint": "explicit"
+    },
+    "editor.formatOnSave": true,
+    "editor.formatOnPaste": true,
+    "editor.formatOnType": true,
+    "json.format.keepLines": true,
+    "[javascript]": {
+      "editor.defaultFormatter": "esbenp.prettier-vscode"
+    },
+    "[typescript]": {
+      "editor.defaultFormatter": "esbenp.prettier-vscode"
+    },
+    "[typescriptreact]": {
+      "editor.defaultFormatter": "esbenp.prettier-vscode"
+    },
+    "[css]": {
+      "editor.defaultFormatter": "esbenp.prettier-vscode"
+    },
+    "[json]": {
+      "editor.defaultFormatter": "vscode.json-language-features"
+    },
+    "search.exclude": {
+      "**/node_modules": true,
+      "static": true
+    },
+    "[python]": {
+      "editor.defaultFormatter": "ms-python.black-formatter",
+      "editor.codeActionsOnSave": {
+        "source.organizeImports": "explicit"
+      }
+    },
+    "flake8.args": [
+      "--max-line-length=119",
+      "--max-complexity=15",
+      "--ignore=E203,E501,E704,W503",
+      "--exclude=.venv,.git,__pycache__,.mypy_cache,.hg"
+    ],
+    "isort.args": ["--settings-path=pyproject.toml"],
+    "black-formatter.args": ["--config=pyproject.toml"],
+    "mypy-type-checker.args": ["--config-file=pyproject.toml"],
+    "python.analysis.extraPaths": ["./backend"]
+  },
+  "extensions": {
+    "recommendations": [
+      "esbenp.prettier-vscode",
+      "dbaeumer.vscode-eslint",
+      "ms-python.flake8",
+      "ms-python.isort",
+      "ms-python.black-formatter",
+      "ms-python.mypy-type-checker"
+    ]
+  }
+}

neollm/__init__.py

@@ -0,0 +1,5 @@
+from neollm.myllm.abstract_myllm import AbstractMyLLM
+from neollm.myllm.myl3m2 import MyL3M2
+from neollm.myllm.myllm import MyLLM
+
+__all__ = ["AbstractMyLLM", "MyLLM", "MyL3M2"]

neollm/exceptions.py

@@ -0,0 +1,2 @@
+class ContentFilterError(Exception):
+    pass

neollm/llm/__init__.py

@@ -0,0 +1,4 @@
+from neollm.llm.abstract_llm import AbstractLLM
+from neollm.llm.get_llm import get_llm
+
+__all__ = ["AbstractLLM", "get_llm"]

neollm/llm/abstract_llm.py

@@ -0,0 +1,188 @@
+from abc import ABC, abstractmethod
+from typing import Any
+
+from neollm.llm.utils import get_entity
+from neollm.types import (
+    APIPricing,
+    ChatCompletion,
+    ChatCompletionMessage,
+    ChatCompletionMessageToolCall,
+    Choice,
+    ChoiceDeltaToolCall,
+    Chunk,
+    ClientSettings,
+    CompletionUsage,
+    Function,
+    FunctionCall,
+    LLMSettings,
+    Messages,
+    Response,
+    StreamResponse,
+)
+from neollm.utils.utils import cprint
+
+
+# 現状、Azure, OpenAIに対応
+class AbstractLLM(ABC):
+    dollar_per_ktoken: APIPricing
+    model: str
+    context_window: int
+    _custom_price_calculation: bool = False  # self.tokenではなく、self.custom_tokenを使う場合にTrue
+
+    def __init__(self, client_settings: ClientSettings):
+        """LLMクラスの初期化
+
+        Args:
+            client_settings (ClientSettings): クライアント設定
+        """
+        self.client_settings = client_settings
+
+    def calculate_price(self, num_input_tokens: int = 0, num_output_tokens: int = 0) -> float:
+        """
+        費用の計測
+
+        Args:
+            num_input_tokens (int, optional): 入力のトークン数. Defaults to 0.
+            num_output_tokens (int, optional): 出力のトークン数. Defaults to 0.
+
+        Returns:
+            float: API利用料(USD)
+        """
+        price = (
+            self.dollar_per_ktoken.input * num_input_tokens + self.dollar_per_ktoken.output * num_output_tokens
+        ) / 1000
+        return price
+
+    @abstractmethod
+    def count_tokens(self, messages: Messages | None = None, only_response: bool = False) -> int: ...
+
+    @abstractmethod
+    def encode(self, text: str) -> list[int]: ...
+
+    @abstractmethod
+    def decode(self, encoded: list[int]) -> str: ...
+
+    @abstractmethod
+    def generate(self, messages: Messages, llm_settings: LLMSettings) -> Response:
+        """生成
+
+        Args:
+            messages (Messages): OpenAI仕様のMessages(list[dict])
+
+        Returns:
+            Response: OpenAI likeなResponse
+        """
+
+    @abstractmethod
+    def generate_stream(self, messages: Messages, llm_settings: LLMSettings) -> StreamResponse: ...
+
+    def __repr__(self) -> str:
+        return f"{self.__class__}()"
+
+    def convert_nonstream_response(
+        self, chunk_list: list[Chunk], messages: Messages, functions: Any = None
+    ) -> Response:
+        # messagesとfunctionsはトークン数計測に必要
+        _chunk_choices = [chunk.choices[0] for chunk in chunk_list if len(chunk.choices) > 0]
+        # TODO: n=2以上の場合にwarningを出したい
+
+        # FunctionCall --------------------------------------------------
+        function_call: FunctionCall | None
+        if all([_c.delta.function_call is None for _c in _chunk_choices]):
+            function_call = None
+        else:
+            function_call = FunctionCall(
+                arguments="".join(
+                    [
+                        _c.delta.function_call.arguments
+                        for _c in _chunk_choices
+                        if _c.delta.function_call is not None and _c.delta.function_call.arguments is not None
+                    ]
+                ),
+                name=get_entity(
+                    [_c.delta.function_call.name for _c in _chunk_choices if _c.delta.function_call is not None],
+                    default="",
+                ),
+            )
+
+        # ToolCalls --------------------------------------------------
+        _tool_calls_dict: dict[int, list[ChoiceDeltaToolCall]] = {}  # key=index
+        for _chunk in _chunk_choices:
+            if _chunk.delta.tool_calls is None:
+                continue
+            for _tool_call in _chunk.delta.tool_calls:
+                _tool_calls_dict.setdefault(_tool_call.index, []).append(_tool_call)
+
+        tool_calls: list[ChatCompletionMessageToolCall] | None
+        if sum(len(_tool_calls) for _tool_calls in _tool_calls_dict.values()) == 0:
+            tool_calls = None
+        else:
+            tool_calls = []
+            for _tool_calls in _tool_calls_dict.values():
+                tool_calls.append(
+                    ChatCompletionMessageToolCall(
+                        id=get_entity([_tc.id for _tc in _tool_calls], default=""),
+                        function=Function(
+                            arguments="".join(
+                                [
+                                    _tc.function.arguments
+                                    for _tc in _tool_calls
+                                    if _tc.function is not None and _tc.function.arguments is not None
+                                ]
+                            ),
+                            name=get_entity(
+                                [_tc.function.name for _tc in _tool_calls if _tc.function is not None], default=""
+                            ),
+                        ),
+                        type=get_entity([_tc.type for _tc in _tool_calls], default="function"),
+                    )
+                )
+        message = ChatCompletionMessage(
+            content="".join([_c.delta.content for _c in _chunk_choices if _c.delta.content is not None]),
+            # TODO: ChoiceDeltaのroleなんで、assistant以外も許されてるの？
+            role=get_entity([_c.delta.role for _c in _chunk_choices], default="assistant"),  # type: ignore
+            function_call=function_call,
+            tool_calls=tool_calls,
+        )
+        choice = Choice(
+            index=get_entity([_c.index for _c in _chunk_choices], default=0),
+            message=message,
+            finish_reason=get_entity([_c.finish_reason for _c in _chunk_choices], default=None),
+        )
+
+        # Usage --------------------------------------------------
+        try:
+            for chunk in chunk_list:
+                if getattr(chunk, "tokens"):
+                    prompt_tokens = int(getattr(chunk, "tokens")["input_tokens"])
+                    completion_tokens = int(getattr(chunk, "tokens")["output_tokens"])
+            assert prompt_tokens
+            assert completion_tokens
+        except Exception:
+            prompt_tokens = self.count_tokens(messages)  # TODO: fcなど
+            completion_tokens = self.count_tokens([message.to_typeddict_message()], only_response=True)
+        usages = CompletionUsage(
+            completion_tokens=completion_tokens,
+            prompt_tokens=prompt_tokens,
+            total_tokens=prompt_tokens + completion_tokens,
+        )
+
+        # ChatCompletion ------------------------------------------
+        response = ChatCompletion(
+            id=get_entity([chunk.id for chunk in chunk_list], default=""),
+            object="chat.completion",
+            created=get_entity([getattr(chunk, "created", 0) for chunk in chunk_list], default=0),
+            model=get_entity([getattr(chunk, "model", "") for chunk in chunk_list], default=""),
+            choices=[choice],
+            system_fingerprint=get_entity(
+                [getattr(chunk, "system_fingerprint", None) for chunk in chunk_list], default=None
+            ),
+            usage=usages,
+        )
+
+        return response
+
+    @property
+    def max_tokens(self) -> int:
+        cprint("max_tokensは非推奨です。context_windowを使用してください。")
+        return self.context_window

neollm/llm/claude/abstract_claude.py

@@ -0,0 +1,214 @@
+import time
+from abc import abstractmethod
+from typing import Any, Literal, cast
+
+from anthropic import Anthropic, AnthropicBedrock, AnthropicVertex, Stream
+from anthropic.types import MessageParam as AnthropicMessageParam
+from anthropic.types import MessageStreamEvent as AnthropicMessageStreamEvent
+from anthropic.types.message import Message as AnthropicMessage
+
+from neollm.llm.abstract_llm import AbstractLLM
+from neollm.types import (
+    ChatCompletion,
+    LLMSettings,
+    Message,
+    Messages,
+    Response,
+    StreamResponse,
+)
+from neollm.types.openai.chat_completion import (
+    ChatCompletionMessage,
+    Choice,
+    CompletionUsage,
+    FinishReason,
+)
+from neollm.types.openai.chat_completion_chunk import (
+    ChatCompletionChunk,
+    ChoiceDelta,
+    ChunkChoice,
+)
+from neollm.utils.utils import cprint
+
+DEFAULT_MAX_TOKENS = 4_096
+
+
+class AbstractClaude(AbstractLLM):
+    @property
+    @abstractmethod
+    def client(self) -> Anthropic | AnthropicVertex | AnthropicBedrock: ...
+
+    @property
+    def _client_for_token(self) -> Anthropic:
+        """トークンカウント用のAnthropicクライアント取得
+        (AnthropicBedrock, AnthropicVertexがmethodを持っていないため)
+
+        Returns:
+            Anthropic: Anthropicクライアント
+        """
+        return Anthropic()
+
+    def encode(self, text: str) -> list[int]:
+        tokenizer = self._client_for_token.get_tokenizer()
+        encoded = cast(list[int], tokenizer.encode(text).ids)
+        return encoded
+
+    def decode(self, decoded: list[int]) -> str:
+        tokenizer = self._client_for_token.get_tokenizer()
+        text = cast(str, tokenizer.decode(decoded))
+        return text
+
+    def count_tokens(self, messages: list[Message] | None = None, only_response: bool = False) -> int:
+        """
+        トークン数の計測
+
+        Args:
+            messages (Messages): messages
+
+        Returns:
+            int: トークン数
+        """
+        if messages is None:
+            return 0
+        tokens = 0
+        for message in messages:
+            content = message["content"]
+            if isinstance(content, str):
+                tokens += self._client_for_token.count_tokens(content)
+                continue
+            if isinstance(content, list):
+                for content_i in content:
+                    if content_i["type"] == "text":
+                        tokens += self._client_for_token.count_tokens(content_i["text"])
+                continue
+        return tokens
+
+    def _convert_finish_reason(
+        self, stop_reason: Literal["end_turn", "max_tokens", "stop_sequence"] | None
+    ) -> FinishReason | None:
+        if stop_reason == "max_tokens":
+            return "length"
+        if stop_reason == "stop_sequence":
+            return "stop"
+        return None
+
+    def _convert_to_response(self, platform_response: AnthropicMessage) -> Response:
+        return ChatCompletion(
+            id=platform_response.id,
+            choices=[
+                Choice(
+                    index=0,
+                    message=ChatCompletionMessage(
+                        content=platform_response.content[0].text if len(platform_response.content) > 0 else "",
+                        role="assistant",
+                    ),
+                    finish_reason=self._convert_finish_reason(platform_response.stop_reason),
+                )
+            ],
+            created=int(time.time()),
+            model=self.model,
+            object="messages.create",
+            system_fingerprint=None,
+            usage=CompletionUsage(
+                prompt_tokens=platform_response.usage.input_tokens,
+                completion_tokens=platform_response.usage.output_tokens,
+                total_tokens=platform_response.usage.input_tokens + platform_response.usage.output_tokens,
+            ),
+        )
+
+    def _convert_to_platform_messages(self, messages: Messages) -> tuple[str, list[AnthropicMessageParam]]:
+        _system = ""
+        _message: list[AnthropicMessageParam] = []
+        for message in messages:
+            if message["role"] == "system":
+                _system += "\n" + message["content"]
+            elif message["role"] == "user":
+                if isinstance(message["content"], str):
+                    _message.append({"role": "user", "content": message["content"]})
+                else:
+                    cprint("WARNING: 未対応です", color="yellow", background=True)
+            elif message["role"] == "assistant":
+                if isinstance(message["content"], str):
+                    _message.append({"role": "assistant", "content": message["content"]})
+                else:
+                    cprint("WARNING: 未対応です", color="yellow", background=True)
+            else:
+                cprint("WARNING: 未対応です", color="yellow", background=True)
+        return _system, _message
+
+    def _convert_to_streamresponse(
+        self, platform_streamresponse: Stream[AnthropicMessageStreamEvent]
+    ) -> StreamResponse:
+        created = int(time.time())
+        model = ""
+        id_ = ""
+        content: str | None = None
+        for chunk in platform_streamresponse:
+            input_tokens = 0
+            output_tokens = 0
+            if chunk.type == "message_stop" or chunk.type == "content_block_stop":
+                continue
+            if chunk.type == "message_start":
+                model = model or chunk.message.model
+                id_ = id_ or chunk.message.id
+                input_tokens = chunk.message.usage.input_tokens
+                output_tokens = chunk.message.usage.output_tokens
+                content = "".join([content_block.text for content_block in chunk.message.content])
+                finish_reason = self._convert_finish_reason(chunk.message.stop_reason)
+            elif chunk.type == "message_delta":
+                content = ""
+                finish_reason = self._convert_finish_reason(chunk.delta.stop_reason)
+                output_tokens = chunk.usage.output_tokens
+            elif chunk.type == "content_block_start":
+                content = chunk.content_block.text
+                finish_reason = None
+            elif chunk.type == "content_block_delta":
+                content = chunk.delta.text
+                finish_reason = None
+            yield ChatCompletionChunk(
+                id=id_,
+                choices=[
+                    ChunkChoice(
+                        delta=ChoiceDelta(
+                            content=content,
+                            role="assistant",
+                        ),
+                        finish_reason=finish_reason,
+                        index=0,  # 0-indexedじゃないかもしれないので0に塗り替え
+                    )
+                ],
+                created=created,
+                model=model,
+                object="chat.completion.chunk",
+                tokens={"input_tokens": input_tokens, "output_tokens": output_tokens},  # type: ignore
+            )
+
+    def generate(self, messages: Messages, llm_settings: LLMSettings) -> Response:
+        _system, _message = self._convert_to_platform_messages(messages)
+        llm_settings = self._set_max_tokens(llm_settings)
+        response = self.client.messages.create(
+            model=self.model,
+            system=_system,
+            messages=_message,
+            stream=False,
+            **llm_settings,
+        )
+        return self._convert_to_response(platform_response=response)
+
+    def generate_stream(self, messages: Any, llm_settings: LLMSettings) -> StreamResponse:
+        _system, _message = self._convert_to_platform_messages(messages)
+        llm_settings = self._set_max_tokens(llm_settings)
+        response = self.client.messages.create(
+            model=self.model,
+            system=_system,
+            messages=_message,
+            stream=True,
+            **llm_settings,
+        )
+        return self._convert_to_streamresponse(platform_streamresponse=response)
+
+    def _set_max_tokens(self, llm_settings: LLMSettings) -> LLMSettings:
+        # claudeはmax_tokensが必須
+        if not llm_settings.get("max_tokens"):
+            cprint(f"max_tokens is not set. Set to {DEFAULT_MAX_TOKENS}.", color="yellow")
+            llm_settings["max_tokens"] = DEFAULT_MAX_TOKENS
+        return llm_settings

neollm/llm/claude/anthropic_llm.py

@@ -0,0 +1,66 @@
+from typing import Literal, cast, get_args
+
+from anthropic import Anthropic
+
+from neollm.llm.abstract_llm import AbstractLLM
+from neollm.llm.claude.abstract_claude import AbstractClaude
+from neollm.types import APIPricing, ClientSettings
+from neollm.utils.utils import cprint
+
+# price: https://www.anthropic.com/api
+# models: https://docs.anthropic.com/claude/docs/models-overview
+
+SUPPORTED_MODELS = Literal[
+    "claude-3-opus-20240229",
+    "claude-3-sonnet-20240229",
+    "claude-3-haiku-20240307",
+]
+
+
+def get_anthoropic_llm(model_name: SUPPORTED_MODELS | str, client_settings: ClientSettings) -> AbstractLLM:
+    # Add 日付
+    replace_map_for_nodate: dict[str, SUPPORTED_MODELS] = {
+        "claude-3-opus": "claude-3-opus-20240229",
+        "claude-3-sonnet": "claude-3-sonnet-20240229",
+        "claude-3-haiku": "claude-3-haiku-20240307",
+    }
+    if model_name in replace_map_for_nodate:
+        cprint("WARNING: model_nameに日付を指定してください", color="yellow", background=True)
+        print(f"model_name: {model_name} -> {replace_map_for_nodate[model_name]}")
+        model_name = replace_map_for_nodate[model_name]
+
+    # map to LLM
+    supported_model_map: dict[SUPPORTED_MODELS, AbstractLLM] = {
+        "claude-3-opus-20240229": AnthropicClaude3Opus20240229(client_settings),
+        "claude-3-sonnet-20240229": AnthropicClaude3Sonnet20240229(client_settings),
+        "claude-3-haiku-20240307": AnthropicClaude3Haiku20240229(client_settings),
+    }
+    if model_name in supported_model_map:
+        model_name = cast(SUPPORTED_MODELS, model_name)
+        return supported_model_map[model_name]
+    raise ValueError(f"model_name must be {get_args(SUPPORTED_MODELS)}, but got {model_name}.")
+
+
+class AnthoropicLLM(AbstractClaude):
+    @property
+    def client(self) -> Anthropic:
+        client = Anthropic(**self.client_settings)
+        return client
+
+
+class AnthropicClaude3Opus20240229(AnthoropicLLM):
+    dollar_per_ktoken = APIPricing(input=15 / 1000, output=75 / 1000)
+    model: str = "claude-3-opus-20240229"
+    context_window: int = 200_000
+
+
+class AnthropicClaude3Sonnet20240229(AnthoropicLLM):
+    dollar_per_ktoken = APIPricing(input=3 / 1000, output=15 / 1000)
+    model: str = "claude-3-sonnet-20240229"
+    context_window: int = 200_000
+
+
+class AnthropicClaude3Haiku20240229(AnthoropicLLM):
+    dollar_per_ktoken = APIPricing(input=0.25 / 1000, output=1.25 / 1000)
+    model: str = "claude-3-haiku-20240307"
+    context_window: int = 200_000

neollm/llm/claude/gcp_llm.py

@@ -0,0 +1,67 @@
+from typing import Literal, cast, get_args
+
+from anthropic import AnthropicVertex
+
+from neollm.llm.abstract_llm import AbstractLLM
+from neollm.llm.claude.abstract_claude import AbstractClaude
+from neollm.types import APIPricing, ClientSettings
+from neollm.utils.utils import cprint
+
+# price: https://www.anthropic.com/api
+# models: https://docs.anthropic.com/claude/docs/models-overview
+
+SUPPORTED_MODELS = Literal[
+    "claude-3-opus@20240229",
+    "claude-3-sonnet@20240229",
+    "claude-3-haiku@20240307",
+]
+
+
+# TODO! google 動かしたいね
+def get_gcp_llm(model_name: SUPPORTED_MODELS | str, client_settings: ClientSettings) -> AbstractLLM:
+    # Add 日付
+    replace_map_for_nodate: dict[str, SUPPORTED_MODELS] = {
+        "claude-3-opus": "claude-3-opus@20240229",
+        "claude-3-sonnet": "claude-3-sonnet@20240229",
+        "claude-3-haiku": "claude-3-haiku@20240307",
+    }
+    if model_name in replace_map_for_nodate:
+        cprint("WARNING: model_nameに日付を指定してください", color="yellow", background=True)
+        print(f"model_name: {model_name} -> {replace_map_for_nodate[model_name]}")
+        model_name = replace_map_for_nodate[model_name]
+
+    # map to LLM
+    supported_model_map: dict[SUPPORTED_MODELS, AbstractLLM] = {
+        "claude-3-opus@20240229": GCPClaude3Opus20240229(client_settings),
+        "claude-3-sonnet@20240229": GCPClaude3Sonnet20240229(client_settings),
+        "claude-3-haiku@20240307": GCPClaude3Haiku20240229(client_settings),
+    }
+    if model_name in supported_model_map:
+        model_name = cast(SUPPORTED_MODELS, model_name)
+        return supported_model_map[model_name]
+    raise ValueError(f"model_name must be {get_args(SUPPORTED_MODELS)}, but got {model_name}.")
+
+
+class GoogleLLM(AbstractClaude):
+    @property
+    def client(self) -> AnthropicVertex:
+        client = AnthropicVertex(**self.client_settings)
+        return client
+
+
+class GCPClaude3Opus20240229(GoogleLLM):
+    dollar_per_ktoken = APIPricing(input=15 / 1000, output=75 / 1000)
+    model: str = "claude-3-opus@20240229"
+    context_window: int = 200_000
+
+
+class GCPClaude3Sonnet20240229(GoogleLLM):
+    dollar_per_ktoken = APIPricing(input=3 / 1000, output=15 / 1000)
+    model: str = "claude-3-sonnet@20240229"
+    context_window: int = 200_000
+
+
+class GCPClaude3Haiku20240229(GoogleLLM):
+    dollar_per_ktoken = APIPricing(input=0.25 / 1000, output=1.25 / 1000)
+    model: str = "claude-3-haiku@20240307"
+    context_window: int = 200_000

neollm/llm/gemini/abstract_gemini.py

@@ -0,0 +1,229 @@
+import time
+from abc import abstractmethod
+from typing import Iterable, cast
+
+from google.cloud.aiplatform_v1beta1.types import CountTokensResponse
+from google.cloud.aiplatform_v1beta1.types.content import Candidate
+from vertexai.generative_models import (
+    Content,
+    GenerationConfig,
+    GenerationResponse,
+    GenerativeModel,
+    Part,
+)
+from vertexai.generative_models._generative_models import ContentsType
+
+from neollm.llm.abstract_llm import AbstractLLM
+from neollm.types import (
+    ChatCompletion,
+    CompletionUsageForCustomPriceCalculation,
+    LLMSettings,
+    Message,
+    Messages,
+    Response,
+    StreamResponse,
+)
+from neollm.types.openai.chat_completion import (
+    ChatCompletionMessage,
+    Choice,
+    CompletionUsage,
+)
+from neollm.types.openai.chat_completion import FinishReason as FinishReasonVertex
+from neollm.types.openai.chat_completion_chunk import (
+    ChatCompletionChunk,
+    ChoiceDelta,
+    ChunkChoice,
+)
+from neollm.utils.utils import cprint
+
+
+class AbstractGemini(AbstractLLM):
+
+    @abstractmethod
+    def generate_config(self, llm_settings: LLMSettings) -> GenerationConfig: ...
+
+    # 使っていない
+    def encode(self, text: str) -> list[int]:
+        return [ord(char) for char in text]
+
+    # 使っていない
+    def decode(self, decoded: list[int]) -> str:
+        return "".join([chr(number) for number in decoded])
+
+    def _count_tokens_vertex(self, contents: ContentsType) -> CountTokensResponse:
+        model = GenerativeModel(model_name=self.model)
+        return cast(CountTokensResponse, model.count_tokens(contents))
+
+    def count_tokens(self, messages: list[Message] | None = None, only_response: bool = False) -> int:
+        """
+        トークン数の計測
+
+        Args:
+            messages (Messages): messages
+
+        Returns:
+            int: トークン数
+        """
+        if messages is None:
+            return 0
+        _system, _message = self._convert_to_platform_messages(messages)
+        total_tokens = 0
+        if _system:
+            total_tokens += int(self._count_tokens_vertex(_system).total_tokens)
+        if _message:
+            total_tokens = int(self._count_tokens_vertex(_message).total_tokens)
+        return total_tokens
+
+    def _convert_to_platform_messages(self, messages: Messages) -> tuple[str | None, list[Content]]:
+        _system = None
+        _message: list[Content] = []
+
+        for message in messages:
+            if message["role"] == "system":
+                _system = "\n" + message["content"]
+            elif message["role"] == "user":
+                if isinstance(message["content"], str):
+                    _message.append(Content(role="user", parts=[Part.from_text(message["content"])]))
+                else:
+                    try:
+                        if isinstance(message["content"], list) and message["content"][1]["type"] == "image_url":
+                            encoded_image = message["content"][1]["image_url"]["url"].split(",")[-1]
+                            _message.append(
+                                Content(
+                                    role="user",
+                                    parts=[
+                                        Part.from_text(message["content"][0]["text"]),
+                                        Part.from_data(data=encoded_image, mime_type="image/jpeg"),
+                                    ],
+                                )
+                            )
+                    except KeyError:
+                        cprint("WARNING: 未対応です", color="yellow", background=True)
+                    except IndexError:
+                        cprint("WARNING: 未対応です", color="yellow", background=True)
+                    except Exception as e:
+                        cprint(e, color="red", background=True)
+            elif message["role"] == "assistant":
+                if isinstance(message["content"], str):
+                    _message.append(Content(role="model", parts=[Part.from_text(message["content"])]))
+            else:
+                cprint("WARNING: 未対応です", color="yellow", background=True)
+        return _system, _message
+
+    def _convert_finish_reason(self, stop_reason: Candidate.FinishReason) -> FinishReasonVertex | None:
+        """
+        参考記事 : https://ai.google.dev/api/python/google/ai/generativelanguage/Candidate/FinishReason
+
+        0: FINISH_REASON_UNSPECIFIED
+            Default value. This value is unused.
+        1: STOP
+            Natural stop point of the model or provided stop sequence.
+        2: MAX_TOKENS
+            The maximum number of tokens as specified in the request was reached.
+        3: SAFETY
+            The candidate content was flagged for safety reasons.
+        4: RECITATION
+            The candidate content was flagged for recitation reasons.
+        5: OTHER
+            Unknown reason.
+        """
+
+        if stop_reason.value in [0, 3, 4, 5]:
+            return "stop"
+
+        if stop_reason.value in [2]:
+            return "length"
+
+        return None
+
+    def _convert_to_response(
+        self, platform_response: GenerationResponse, system: str | None, message: list[Content]
+    ) -> Response:
+        # input 請求用文字数
+        input_billable_characters = 0
+        if system:
+            input_billable_characters += self._count_tokens_vertex(system).total_billable_characters
+        if message:
+            input_billable_characters += self._count_tokens_vertex(message).total_billable_characters
+        # output 請求用文字数
+        output_billable_characters = 0
+        if platform_response.text:
+            output_billable_characters += self._count_tokens_vertex(platform_response.text).total_billable_characters
+        return ChatCompletion(  # type: ignore [call-arg]
+            id="",
+            choices=[
+                Choice(
+                    index=0,
+                    message=ChatCompletionMessage(
+                        content=platform_response.text,
+                        role="assistant",
+                    ),
+                    finish_reason=self._convert_finish_reason(platform_response.candidates[0].finish_reason),
+                )
+            ],
+            created=int(time.time()),
+            model=self.model,
+            object="messages.create",
+            system_fingerprint=None,
+            usage=CompletionUsage(
+                prompt_tokens=platform_response.usage_metadata.prompt_token_count,
+                completion_tokens=platform_response.usage_metadata.candidates_token_count,
+                total_tokens=platform_response.usage_metadata.prompt_token_count
+                + platform_response.usage_metadata.candidates_token_count,
+            ),
+            usage_for_price=CompletionUsageForCustomPriceCalculation(
+                prompt_tokens=input_billable_characters,
+                completion_tokens=output_billable_characters,
+                total_tokens=input_billable_characters + output_billable_characters,
+            ),
+        )
+
+    def _convert_to_streamresponse(self, platform_streamresponse: Iterable[GenerationResponse]) -> StreamResponse:
+        created = int(time.time())
+        content: str | None = None
+        for chunk in platform_streamresponse:
+            content = chunk.text
+            yield ChatCompletionChunk(
+                id="",
+                choices=[
+                    ChunkChoice(
+                        delta=ChoiceDelta(
+                            content=content,
+                            role="assistant",
+                        ),
+                        finish_reason=self._convert_finish_reason(chunk.candidates[0].finish_reason),
+                        index=0,  # 0-indexedじゃないかもしれないので0に塗り替え
+                    )
+                ],
+                created=created,
+                model=self.model,
+                object="chat.completion.chunk",
+            )
+
+    def generate(self, messages: Messages, llm_settings: LLMSettings) -> Response:
+        _system, _message = self._convert_to_platform_messages(messages)
+        model = GenerativeModel(
+            model_name=self.model,
+            system_instruction=_system,
+        )
+
+        response = model.generate_content(
+            contents=_message,
+            stream=False,
+            generation_config=self.generate_config(llm_settings),
+        )
+
+        return self._convert_to_response(platform_response=response, system=_system, message=_message)
+
+    def generate_stream(self, messages: Messages, llm_settings: LLMSettings) -> StreamResponse:
+        _system, _message = self._convert_to_platform_messages(messages)
+        model = GenerativeModel(
+            model_name=self.model,
+            system_instruction=_system,
+        )
+        response = model.generate_content(
+            contents=_message,
+            stream=True,
+            generation_config=self.generate_config(llm_settings),
+        )
+        return self._convert_to_streamresponse(platform_streamresponse=response)

neollm/llm/gemini/gcp_llm.py

@@ -0,0 +1,114 @@
+from copy import deepcopy
+from typing import Literal, cast, get_args
+
+import vertexai
+from vertexai.generative_models import GenerationConfig
+
+from neollm.llm.abstract_llm import AbstractLLM
+from neollm.llm.gemini.abstract_gemini import AbstractGemini
+from neollm.types import APIPricing, ClientSettings, LLMSettings, StreamResponse
+from neollm.types.mytypes import Messages, Response
+from neollm.utils.utils import cprint
+
+# price: https://ai.google.dev/pricing?hl=ja
+# models: https://ai.google.dev/gemini-api/docs/models/gemini?hl=ja
+
+SUPPORTED_MODELS = Literal["gemini-1.0-pro", "gemini-1.0-pro-vision", "gemini-1.5-pro-preview-0409"]
+AVAILABLE_CONFIG_VARIABLES = [
+    "candidate_count",
+    "stop_sequences",
+    "temperature",
+    "max_tokens",  # "max_output_tokensが設定されていない場合、max_tokensを使う
+    "max_output_tokens",
+    "top_p",
+    "top_k",
+]
+
+
+def get_gcp_llm(model_name: SUPPORTED_MODELS | str, client_settings: ClientSettings) -> AbstractLLM:
+
+    vertexai.init(**client_settings)
+
+    # map to LLM
+    supported_model_map: dict[SUPPORTED_MODELS, AbstractLLM] = {
+        "gemini-1.0-pro": GCPGemini10Pro(client_settings),
+        "gemini-1.0-pro-vision": GCPGemini10ProVision(client_settings),
+        "gemini-1.5-pro-preview-0409": GCPGemini15Pro0409(client_settings),
+    }
+    if model_name in supported_model_map:
+        model_name = cast(SUPPORTED_MODELS, model_name)
+        return supported_model_map[model_name]
+    raise ValueError(f"model_name must be {get_args(SUPPORTED_MODELS)}, but got {model_name}.")
+
+
+class GoogleLLM(AbstractGemini):
+
+    def generate_config(self, llm_settings: LLMSettings) -> GenerationConfig:
+        """
+        参考記事 : https://ai.google.dev/api/rest/v1/GenerationConfig?hl=ja
+        """
+        # gemini
+        candidate_count = llm_settings.pop("candidate_count", None)
+        stop_sequences = llm_settings.pop("stop_sequences", None)
+        temperature = llm_settings.pop("temperature", None)
+        max_output_tokens = llm_settings.pop("max_output_tokens", None)
+        top_p = llm_settings.pop("top_p", None)
+        top_k = llm_settings.pop("top_k", None)
+
+        # neollmの引数でも動くようにする
+        if max_output_tokens is None:
+            max_output_tokens = llm_settings.pop("max_tokens", None)
+
+        if len(llm_settings) > 0 and "max_tokens" not in llm_settings:
+            raise ValueError(f"llm_settings has unknown keys: {llm_settings}")
+
+        return GenerationConfig(
+            candidate_count=candidate_count,
+            stop_sequences=stop_sequences,
+            temperature=temperature,
+            max_output_tokens=max_output_tokens,
+            top_p=top_p,
+            top_k=top_k,
+        )
+
+
+class GCPGemini10Pro(GoogleLLM):
+    dollar_per_ktoken = APIPricing(input=0.125 / 1000, output=0.375 / 1000)
+    model: str = "gemini-1.0-pro"
+    context_window: int = 32_000
+
+
+class GCPGemini10ProVision(GoogleLLM):
+    dollar_per_ktoken = APIPricing(input=0.125 / 1000, output=0.375 / 1000)
+    model: str = "gemini-1.0-pro-vision"
+    context_window: int = 32_000
+
+    def generate(self, messages: Messages, llm_settings: LLMSettings) -> Response:
+        messages = self._preprocess_message_to_use_system(messages)
+        return super().generate(messages, llm_settings)
+
+    def generate_stream(self, messages: Messages, llm_settings: LLMSettings) -> StreamResponse:
+        messages = self._preprocess_message_to_use_system(messages)
+        return super().generate_stream(messages, llm_settings)
+
+    def _preprocess_message_to_use_system(self, message: Messages) -> Messages:
+        if message[0]["role"] != "system":
+            return message
+        preprocessed_message = deepcopy(message)
+        system = preprocessed_message[0]["content"]
+        del preprocessed_message[0]
+        if (
+            isinstance(system, str)
+            and isinstance(preprocessed_message[0]["content"], list)
+            and isinstance(preprocessed_message[0]["content"][0]["text"], str)
+        ):
+            preprocessed_message[0]["content"][0]["text"] = system + preprocessed_message[0]["content"][0]["text"]
+        else:
+            cprint("WARNING: 入力形式が不正です", color="yellow", background=True)
+        return preprocessed_message
+
+
+class GCPGemini15Pro0409(GoogleLLM):
+    dollar_per_ktoken = APIPricing(input=2.5 / 1000, output=7.5 / 1000)
+    model: str = "gemini-1.5-pro-preview-0409"
+    context_window: int = 1_000_000

neollm/llm/get_llm.py

@@ -0,0 +1,47 @@
+from neollm.llm.abstract_llm import AbstractLLM
+from neollm.types import ClientSettings
+
+from .platform import Platform
+
+SUPPORTED_CLAUDE_MODELS = [
+    "claude-3-opus",
+    "claude-3-sonnet",
+    "claude-3-haiku",
+    "claude-3-opus@20240229",
+    "claude-3-sonnet@20240229",
+    "claude-3-haiku@20240307",
+]
+
+SUPPORTED_GEMINI_MODELS = [
+    "gemini-1.5-pro-preview-0409",
+    "gemini-1.0-pro",
+    "gemini-1.0-pro-vision",
+]
+
+
+def get_llm(model_name: str, platform: str, client_settings: ClientSettings) -> AbstractLLM:
+    platform = Platform(platform)
+    # llmの取得
+    if platform == Platform.AZURE:
+        from neollm.llm.gpt.azure_llm import get_azure_llm
+
+        return get_azure_llm(model_name, client_settings)
+    if platform == Platform.OPENAI:
+        from neollm.llm.gpt.openai_llm import get_openai_llm
+
+        return get_openai_llm(model_name, client_settings)
+    if platform == Platform.ANTHROPIC:
+        from neollm.llm.claude.anthropic_llm import get_anthoropic_llm
+
+        return get_anthoropic_llm(model_name, client_settings)
+    if platform == Platform.GCP:
+        if model_name in SUPPORTED_CLAUDE_MODELS:
+            from neollm.llm.claude.gcp_llm import get_gcp_llm as get_gcp_llm_for_claude
+
+            return get_gcp_llm_for_claude(model_name, client_settings)
+        elif model_name in SUPPORTED_GEMINI_MODELS:
+            from neollm.llm.gemini.gcp_llm import get_gcp_llm as get_gcp_llm_for_gemini
+
+            return get_gcp_llm_for_gemini(model_name, client_settings)
+        else:
+            raise ValueError(f"{model_name} is not supported in GCP.")

neollm/llm/gpt/abstract_gpt.py

@@ -0,0 +1,81 @@
+import tiktoken
+
+from neollm.llm.abstract_llm import AbstractLLM
+from neollm.types import (
+    ChatCompletion,
+    ChatCompletionChunk,
+    Message,
+    Messages,
+    OpenAIMessages,
+    OpenAIResponse,
+    OpenAIStreamResponse,
+    Response,
+    StreamResponse,
+)
+
+
+class AbstractGPT(AbstractLLM):
+    def encode(self, text: str) -> list[int]:
+        tokenizer = tiktoken.encoding_for_model(self.model or "gpt-3.5-turbo")
+        return tokenizer.encode(text)
+
+    def decode(self, encoded: list[int]) -> str:
+        tokenizer = tiktoken.encoding_for_model(self.model or "gpt-3.5-turbo")
+        return tokenizer.decode(encoded)
+
+    def count_tokens(self, messages: list[Message] | None = None, only_response: bool = False) -> int:
+        """
+        トークン数の計測
+
+        Args:
+            messages (Messages): messages
+
+        Returns:
+            int: トークン数
+        """
+        if messages is None:
+            return 0
+
+        # count tokens
+        num_tokens: int = 0
+        # messages ---------------------------------------------------------------------------v
+        for message in messages:
+            # per message -------------------------------------------
+            num_tokens += 4
+            # content -----------------------------------------------
+            content = message.get("content", None)
+            if content is None:
+                num_tokens += 0
+            elif isinstance(content, str):
+                num_tokens += len(self.encode(content))
+                continue
+            elif isinstance(content, list):
+                for content_params in content:
+                    if content_params["type"] == "text":
+                        num_tokens += len(self.encode(content_params["text"]))
+            # TODO: ChatCompletionFunctionMessageParam.name
+            # tokens_per_name = 1
+            # tool calls ------------------------------------------------
+            # TODO: ChatCompletionAssistantMessageParam.function_call
+            # TODO: ChatCompletionAssistantMessageParam.tool_calls
+
+        if only_response:
+            if len(messages) != 1:
+                raise ValueError("only_response=Trueの場合、messagesは1つのみにしてください。")
+            num_tokens -= 4  # per message分を消す
+        else:
+            num_tokens += 3  # every reply is primed with <|start|>assistant<|message|>
+
+        return num_tokens
+
+    def _convert_to_response(self, platform_response: OpenAIResponse) -> Response:
+        return ChatCompletion(**platform_response.model_dump())
+
+    def _convert_to_platform_messages(self, messages: Messages) -> OpenAIMessages:
+        # OpenAIのMessagesをデフォルトに置いているため、変換は不要
+        platform_messages: OpenAIMessages = messages
+        return platform_messages
+
+    def _convert_to_streamresponse(self, platform_streamresponse: OpenAIStreamResponse) -> StreamResponse:
+        for chunk in platform_streamresponse:
+            yield ChatCompletionChunk(**chunk.model_dump())

neollm/llm/gpt/azure_llm.py

@@ -0,0 +1,215 @@
+from typing import Literal, cast
+
+from openai import AzureOpenAI
+
+from neollm.llm.abstract_llm import AbstractLLM
+from neollm.llm.gpt.abstract_gpt import AbstractGPT
+from neollm.types import (
+    APIPricing,
+    ClientSettings,
+    LLMSettings,
+    Messages,
+    Response,
+    StreamResponse,
+)
+from neollm.utils.utils import cprint, ensure_env_var, suport_unrecomended_env_var
+
+suport_unrecomended_env_var(old_key="AZURE_API_BASE", new_key="AZURE_OPENAI_ENDPOINT")
+suport_unrecomended_env_var(old_key="AZURE_API_VERSION", new_key="OPENAI_API_VERSION")
+# 0613なし
+suport_unrecomended_env_var(old_key="AZURE_ENGINE_GPT35", new_key="AZURE_ENGINE_GPT35T_0613")
+suport_unrecomended_env_var(old_key="AZURE_ENGINE_GPT35_16k", new_key="AZURE_ENGINE_GPT35T_16K_0613")
+suport_unrecomended_env_var(old_key="AZURE_ENGINE_GPT4", new_key="AZURE_ENGINE_GPT4_0613")
+suport_unrecomended_env_var(old_key="AZURE_ENGINE_GPT4_32k", new_key="AZURE_ENGINE_GPT4_32K_0613")
+# turbo抜け
+suport_unrecomended_env_var(old_key="AZURE_ENGINE_GPT35_0613", new_key="AZURE_ENGINE_GPT35T_0613")
+suport_unrecomended_env_var(old_key="AZURE_ENGINE_GPT35_16K_0613", new_key="AZURE_ENGINE_GPT35T_16K_0613")
+
+# Pricing: https://azure.microsoft.com/en-us/pricing/details/cognitive-services/openai-service/
+
+SUPPORTED_MODELS = Literal[
+    "gpt-4o-2024-05-13",
+    "gpt-4-turbo-2024-04-09",
+    "gpt-3.5-turbo-0125",
+    "gpt-4-turbo-0125",
+    "gpt-3.5-turbo-1106",
+    "gpt-4-turbo-1106",
+    "gpt-4v-turbo-1106",
+    "gpt-3.5-turbo-0613",
+    "gpt-3.5-turbo-16k-0613",
+    "gpt-4-0613",
+    "gpt-4-32k-0613",
+]
+
+
+def get_azure_llm(model_name: SUPPORTED_MODELS | str, client_settings: ClientSettings) -> AbstractLLM:
+    # 表記変更
+    model_name = model_name.replace("gpt-35-turbo", "gpt-3.5-turbo")
+    # Add 日付
+    replace_map_for_nodate: dict[str, SUPPORTED_MODELS] = {
+        "gpt-4o": "gpt-4o-2024-05-13",
+        "gpt-3.5-turbo": "gpt-3.5-turbo-0613",
+        "gpt-3.5-turbo-16k": "gpt-3.5-turbo-16k-0613",
+        "gpt-4": "gpt-4-0613",
+        "gpt-4-32k": "gpt-4-32k-0613",
+        "gpt-4-turbo": "gpt-4-turbo-1106",
+        "gpt-4v-turbo": "gpt-4v-turbo-1106",
+    }
+    if model_name in replace_map_for_nodate:
+        cprint("WARNING: model_nameに日付を指定してください", color="yellow", background=True)
+        print(f"model_name: {model_name} -> {replace_map_for_nodate[model_name]}")
+        model_name = replace_map_for_nodate[model_name]
+
+    # map to LLM
+    supported_model_map: dict[SUPPORTED_MODELS, AbstractLLM] = {
+        "gpt-4o-2024-05-13": AzureGPT4O_20240513(client_settings),
+        "gpt-4-turbo-2024-04-09": AzureGPT4T_20240409(client_settings),
+        "gpt-3.5-turbo-0125": AzureGPT35T_0125(client_settings),
+        "gpt-4-turbo-0125": AzureGPT4T_0125(client_settings),
+        "gpt-3.5-turbo-1106": AzureGPT35T_1106(client_settings),
+        "gpt-4-turbo-1106": AzureGPT4T_1106(client_settings),
+        "gpt-4v-turbo-1106": AzureGPT4VT_1106(client_settings),
+        "gpt-3.5-turbo-0613": AzureGPT35T_0613(client_settings),
+        "gpt-3.5-turbo-16k-0613": AzureGPT35T16k_0613(client_settings),
+        "gpt-4-0613": AzureGPT4_0613(client_settings),
+        "gpt-4-32k-0613": AzureGPT432k_0613(client_settings),
+    }
+    # 通常モデル
+    if model_name in supported_model_map:
+        model_name = cast(SUPPORTED_MODELS, model_name)
+        return supported_model_map[model_name]
+    # FTモデル
+    return AzureGPT35FT(model_name, client_settings)
+
+
+class AzureLLM(AbstractGPT):
+    _engine_name_env_key: str | None = None
+
+    @property
+    def client(self) -> AzureOpenAI:
+        client: AzureOpenAI = AzureOpenAI(**self.client_settings)
+        # api_key: str | None = (None,)
+        # timeout: httpx.Timeout(timeout=600.0, connect=5.0)
+        # max_retries: int = 2
+        return client
+
+    @property
+    def engine(self) -> str:
+        return ensure_env_var(self._engine_name_env_key)
+
+    def generate(self, messages: Messages, llm_settings: LLMSettings) -> Response:
+        openai_response = self.client.chat.completions.create(
+            model=self.engine,
+            messages=self._convert_to_platform_messages(messages),
+            stream=False,
+            **llm_settings,
+        )
+        response = self._convert_to_response(openai_response)
+        return response
+
+    def generate_stream(self, messages: Messages, llm_settings: LLMSettings) -> StreamResponse:
+        platform_stream_response = self.client.chat.completions.create(
+            model=self.engine,
+            messages=self._convert_to_platform_messages(messages),
+            stream=True,
+            **llm_settings,
+        )
+        stream_response = self._convert_to_streamresponse(platform_stream_response)
+        return stream_response
+
+
+# omni 2024-05-13 --------------------------------------------------------------------------------------------
+class AzureGPT4O_20240513(AzureLLM):
+    dollar_per_ktoken = APIPricing(input=0.005, output=0.015)  # 30倍/45倍
+    model: str = "gpt-4o-2024-05-13"
+    _engine_name_env_key: str = "AZURE_ENGINE_GPT4O_20240513"
+    context_window: int = 128_000
+
+
+# 2024-04-09 --------------------------------------------------------------------------------------------
+class AzureGPT4T_20240409(AzureLLM):
+    dollar_per_ktoken = APIPricing(input=0.01, output=0.03)
+    model: str = "gpt-4-turbo-2024-04-09"
+    _engine_name_env_key: str = "AZURE_ENGINE_GPT4T_20240409"
+    context_window: int = 128_000
+
+
+# 0125 --------------------------------------------------------------------------------------------
+class AzureGPT35T_0125(AzureLLM):
+    dollar_per_ktoken = APIPricing(input=0.0005, output=0.0015)
+    model: str = "gpt-3.5-turbo-0125"
+    _engine_name_env_key: str = "AZURE_ENGINE_GPT35T_0125"
+    context_window: int = 16_385
+
+
+class AzureGPT4T_0125(AzureLLM):
+    dollar_per_ktoken = APIPricing(input=0.01, output=0.03)
+    model: str = "gpt-4-turbo-0125"
+    _engine_name_env_key: str = "AZURE_ENGINE_GPT4T_0125"
+    context_window: int = 128_000
+
+
+# 1106 --------------------------------------------------------------------------------------------
+class AzureGPT35T_1106(AzureLLM):
+    dollar_per_ktoken = APIPricing(input=0.001, output=0.002)
+    model: str = "gpt-3.5-turbo-1106"
+    _engine_name_env_key: str = "AZURE_ENGINE_GPT35T_1106"
+    context_window: int = 16_385
+
+
+class AzureGPT4VT_1106(AzureLLM):
+    dollar_per_ktoken = APIPricing(input=0.01, output=0.03)  # 10倍/15倍
+    model: str = "gpt-4-1106-vision-preview"
+    _engine_name_env_key: str = "AZURE_ENGINE_GPT4VT_1106"
+    context_window: int = 128_000
+
+
+class AzureGPT4T_1106(AzureLLM):
+    dollar_per_ktoken = APIPricing(input=0.01, output=0.03)
+    model: str = "gpt-4-turbo-1106"
+    _engine_name_env_key: str = "AZURE_ENGINE_GPT4T_1106"
+    context_window: int = 128_000
+
+
+# FT --------------------------------------------------------------------------------------------
+class AzureGPT35FT(AzureLLM):
+    dollar_per_ktoken = APIPricing(input=0.0005, output=0.0015)  # 1倍 + セッション稼働時間
+    model: str = "gpt-3.5-turbo-ft"
+    context_window: int = 4_096
+
+    def __init__(self, model_name: str, client_setting: ClientSettings) -> None:
+        super().__init__(client_setting)
+        self._engine = model_name
+
+    @property
+    def engine(self) -> str:
+        return self._engine
+
+
+# 0613 --------------------------------------------------------------------------------------------
+class AzureGPT35T_0613(AzureLLM):
+    dollar_per_ktoken = APIPricing(input=0.0015, output=0.002)
+    model: str = "gpt-3.5-turbo-0613"
+    _engine_name_env_key: str = "AZURE_ENGINE_GPT35T_0613"
+    context_window: int = 4_096
+
+
+class AzureGPT35T16k_0613(AzureLLM):
+    dollar_per_ktoken = APIPricing(input=0.003, output=0.004)  # 2倍
+    model: str = "gpt-3.5-turbo-16k-0613"
+    _engine_name_env_key: str = "AZURE_ENGINE_GPT35T_16K_0613"
+    context_window: int = 16_385
+
+
+class AzureGPT4_0613(AzureLLM):
+    dollar_per_ktoken = APIPricing(input=0.03, output=0.06)  # 20倍/30倍
+    model: str = "gpt-4-0613"
+    _engine_name_env_key: str = "AZURE_ENGINE_GPT4_0613"
+    context_window: int = 8_192
+
+
+class AzureGPT432k_0613(AzureLLM):
+    dollar_per_ktoken = APIPricing(input=0.06, output=0.12)  # 40倍/60倍
+    model: str = "gpt-4-32k-0613"
+    _engine_name_env_key: str = "AZURE_ENGINE_GPT4_32K_0613"
+    context_window: int = 32_768

neollm/llm/gpt/openai_llm.py

@@ -0,0 +1,222 @@
+from typing import Literal, cast
+
+from openai import OpenAI
+
+from neollm.llm.abstract_llm import AbstractLLM
+from neollm.llm.gpt.abstract_gpt import AbstractGPT
+from neollm.types import (
+    APIPricing,
+    ClientSettings,
+    LLMSettings,
+    Messages,
+    Response,
+    StreamResponse,
+)
+from neollm.utils.utils import cprint
+
+# Models: https://platform.openai.com/docs/models/continuous-model-upgrades
+# Pricing: https://openai.com/pricing
+
+SUPPORTED_MODELS = Literal[
+    "gpt-4o-2024-05-13",
+    "gpt-4-turbo-2024-04-09",
+    "gpt-3.5-turbo-0125",
+    "gpt-4-turbo-0125",
+    "gpt-3.5-turbo-1106",
+    "gpt-4-turbo-1106",
+    "gpt-4v-turbo-1106",
+    "gpt-3.5-turbo-0613",
+    "gpt-3.5-turbo-16k-0613",
+    "gpt-4-0613",
+    "gpt-4-32k-0613",
+]
+
+
+def get_openai_llm(model_name: SUPPORTED_MODELS | str, client_settings: ClientSettings) -> AbstractLLM:
+    # Add 日付
+    replace_map_for_nodate: dict[str, SUPPORTED_MODELS] = {
+        "gpt-4o": "gpt-4o-2024-05-13",
+        "gpt-3.5-turbo": "gpt-3.5-turbo-0613",
+        "gpt-3.5-turbo-16k": "gpt-3.5-turbo-16k-0613",
+        "gpt-4": "gpt-4-0613",
+        "gpt-4-32k": "gpt-4-32k-0613",
+        "gpt-4-turbo": "gpt-4-turbo-1106",
+        "gpt-4v-turbo": "gpt-4v-turbo-1106",
+    }
+    if model_name in replace_map_for_nodate:
+        cprint("WARNING: model_nameに日付を指定してください", color="yellow", background=True)
+        print(f"model_name: {model_name} -> {replace_map_for_nodate[model_name]}")
+        model_name = replace_map_for_nodate[model_name]
+
+    # map to LLM
+    supported_model_map: dict[SUPPORTED_MODELS, AbstractLLM] = {
+        "gpt-4o-2024-05-13": OpenAIGPT4O_20240513(client_settings),
+        "gpt-4-turbo-2024-04-09": OpenAIGPT4T_20240409(client_settings),
+        "gpt-3.5-turbo-0125": OpenAIGPT35T_0125(client_settings),
+        "gpt-4-turbo-0125": OpenAIGPT4T_0125(client_settings),
+        "gpt-3.5-turbo-1106": OpenAIGPT35T_1106(client_settings),
+        "gpt-4-turbo-1106": OpenAIGPT4T_1106(client_settings),
+        "gpt-4v-turbo-1106": OpenAIGPT4VT_1106(client_settings),
+        "gpt-3.5-turbo-0613": OpenAIGPT35T_0613(client_settings),
+        "gpt-3.5-turbo-16k-0613": OpenAIGPT35T16k_0613(client_settings),
+        "gpt-4-0613": OpenAIGPT4_0613(client_settings),
+        "gpt-4-32k-0613": OpenAIGPT432k_0613(client_settings),
+    }
+    # 通常モデル
+    if model_name in supported_model_map:
+        model_name = cast(SUPPORTED_MODELS, model_name)
+        return supported_model_map[model_name]
+    # FTモデル
+    if "gpt-3.5-turbo-1106" in model_name:
+        return OpenAIGPT35TFT_1106(model_name, client_settings)
+    if "gpt-3.5-turbo-0613" in model_name:
+        return OpenAIGPT35TFT_0613(model_name, client_settings)
+    if "gpt-3.5-turbo-0125" in model_name:
+        return OpenAIGPT35TFT_0125(model_name, client_settings)
+    if "gpt4" in model_name.replace("-", ""):  # TODO! もっといい条件に修正
+        return OpenAIGPT4FT_0613(model_name, client_settings)
+
+    cprint(
+        f"WARNING: このFTモデルは何？: {model_name} -> OpenAIGPT35TFT_1106として設定", color="yellow", background=True
+    )
+    return OpenAIGPT35TFT_1106(model_name, client_settings)
+
+
+class OpenAILLM(AbstractGPT):
+    model: str
+
+    @property
+    def client(self) -> OpenAI:
+        client: OpenAI = OpenAI(**self.client_settings)
+        # api_key: str | None = (None,)
+        # timeout: httpx.Timeout(timeout=600.0, connect=5.0)
+        # max_retries: int = 2
+        return client
+
+    def generate(self, messages: Messages, llm_settings: LLMSettings) -> Response:
+        openai_response = self.client.chat.completions.create(
+            model=self.model,
+            messages=self._convert_to_platform_messages(messages),
+            stream=False,
+            **llm_settings,
+        )
+        response = self._convert_to_response(openai_response)
+        return response
+
+    def generate_stream(self, messages: Messages, llm_settings: LLMSettings) -> StreamResponse:
+        platform_stream_response = self.client.chat.completions.create(
+            model=self.model,
+            messages=self._convert_to_platform_messages(messages),
+            stream=True,
+            **llm_settings,
+        )
+        stream_response = self._convert_to_streamresponse(platform_stream_response)
+        return stream_response
+
+
+# omni 2024-05-13 --------------------------------------------------------------------------------------------
+class OpenAIGPT4O_20240513(OpenAILLM):
+    dollar_per_ktoken = APIPricing(input=0.005, output=0.015)
+    model: str = "gpt-4o-2024-05-13"
+    context_window: int = 128_000
+
+
+# 2024-04-09 --------------------------------------------------------------------------------------------
+class OpenAIGPT4T_20240409(OpenAILLM):
+    dollar_per_ktoken = APIPricing(input=0.01, output=0.03)  # 10倍/15倍
+    model: str = "gpt-4-turbo-2024-04-09"
+    # model: str = "gpt-4-turbo-2024-04-09"
+    context_window: int = 128_000
+
+
+# 0125 --------------------------------------------------------------------------------------------
+class OpenAIGPT35T_0125(OpenAILLM):
+    dollar_per_ktoken = APIPricing(input=0.0005, output=0.0015)
+    model: str = "gpt-3.5-turbo-0125"
+    context_window: int = 16_385
+
+
+class OpenAIGPT4T_0125(OpenAILLM):
+    dollar_per_ktoken = APIPricing(input=0.01, output=0.03)
+    model: str = "gpt-4-0125-preview"
+    context_window: int = 128_000
+
+
+class OpenAIGPT35TFT_0125(OpenAILLM):
+    dollar_per_ktoken = APIPricing(input=0.003, output=0.006)
+    context_window: int = 16_385
+
+    def __init__(self, model_name: str, client_setting: ClientSettings) -> None:
+        super().__init__(client_setting)
+        self.model = model_name
+
+
+# 1106 --------------------------------------------------------------------------------------------
+class OpenAIGPT35T_1106(OpenAILLM):
+    dollar_per_ktoken = APIPricing(input=0.0010, output=0.0020)
+    model: str = "gpt-3.5-turbo-1106"
+    context_window: int = 16_385
+
+
+class OpenAIGPT4T_1106(OpenAILLM):
+    dollar_per_ktoken = APIPricing(input=0.01, output=0.03)
+    model: str = "gpt-4-1106-preview"
+    context_window: int = 128_000
+
+
+class OpenAIGPT4VT_1106(OpenAILLM):
+    dollar_per_ktoken = APIPricing(input=0.01, output=0.03)
+    model: str = "gpt-4-1106-vision-preview"
+    context_window: int = 128_000
+
+
+class OpenAIGPT35TFT_1106(OpenAILLM):
+    dollar_per_ktoken = APIPricing(input=0.003, output=0.006)
+    context_window: int = 4_096
+
+    def __init__(self, model_name: str, client_setting: ClientSettings) -> None:
+        super().__init__(client_setting)
+        self.model = model_name
+
+
+# 0613 --------------------------------------------------------------------------------------------
+class OpenAIGPT35T_0613(OpenAILLM):
+    dollar_per_ktoken = APIPricing(input=0.0015, output=0.002)
+    model: str = "gpt-3.5-turbo-0613"
+    context_window: int = 4_096
+
+
+class OpenAIGPT35T16k_0613(OpenAILLM):
+    dollar_per_ktoken = APIPricing(input=0.003, output=0.004)
+    model: str = "gpt-3.5-turbo-16k-0613"
+    context_window: int = 16_385
+
+
+class OpenAIGPT4_0613(OpenAILLM):
+    dollar_per_ktoken = APIPricing(input=0.03, output=0.06)
+    model: str = "gpt-4-0613"
+    context_window: int = 8_192
+
+
+class OpenAIGPT432k_0613(OpenAILLM):
+    dollar_per_ktoken = APIPricing(input=0.06, output=0.12)
+    model: str = "gpt-4-32k-0613"
+    context_window: int = 32_768
+
+
+class OpenAIGPT35TFT_0613(OpenAILLM):
+    dollar_per_ktoken = APIPricing(input=0.003, output=0.006)
+    context_window: int = 4_096
+
+    def __init__(self, model_name: str, client_setting: ClientSettings) -> None:
+        super().__init__(client_setting)
+        self.model = model_name
+
+
+class OpenAIGPT4FT_0613(OpenAILLM):
+    dollar_per_ktoken = APIPricing(input=0.045, output=0.090)
+    context_window: int = 8_192
+
+    def __init__(self, model_name: str, client_setting: ClientSettings) -> None:
+        super().__init__(client_setting)
+        self.model = model_name

neollm/llm/gpt/token.py

@@ -0,0 +1,247 @@
+import json
+import textwrap
+from typing import Any, Iterator, overload
+
+import tiktoken
+
+from neollm.types import Function
+from neollm.utils.utils import cprint  # , Functions, Messages
+
+DEFAULT_MODEL_NAME = "gpt-3.5-turbo"
+
+
+def get_tokenizer(model_name: str) -> tiktoken.Encoding:
+    # 参考: https://platform.openai.com/docs/models/gpt-3-5
+    MODEL_NAME_MAP = [
+        ("gpt-3.5-turbo-16k", "gpt-3.5-turbo-16k-0613"),
+        ("gpt-3.5-turbo", "gpt-3.5-turbo-0613"),
+        ("gpt-4-32k", "gpt-4-32k-0613"),
+        ("gpt-4", "gpt-4-0613"),
+    ]
+    ALL_VERSION_MODELS = [
+        # gpt-3.5-turbo
+        "gpt-3.5-turbo-0125",
+        "gpt-3.5-turbo-1106",
+        "gpt-3.5-turbo-0613",
+        "gpt-3.5-turbo-16k-0613",
+        "gpt-3.5-turbo-0301",  # Legacy
+        # gpt-4
+        "gpt-4o-2024-05-13",
+        "gpt-4-turbo-0125",
+        "gpt-4-turbo-1106",
+        "gpt-4-0613",
+        "gpt-4-32k-0613",
+        "gpt-4-0314",  # Legacy
+        "gpt-4-32k-0314",  # Legacy
+    ]
+    # Azure表記 → OpenAI表記に統一
+    model_name = model_name.replace("gpt-35", "gpt-3.5")
+    # 最新モデルを正式名称に & 新モデル, FTモデルをキャッチ
+    if model_name not in ALL_VERSION_MODELS:
+        for key, model_name_version in MODEL_NAME_MAP:
+            if key in model_name:
+                model_name = model_name_version
+                break
+    try:
+        return tiktoken.encoding_for_model(model_name)
+    except Exception as e:
+        cprint(f"WARNING: Tokenizerの取得に失敗。{model_name}: {e}", color="yellow", background=True)
+        return tiktoken.encoding_for_model("gpt-3.5-turbo")
+
+
+@overload
+def count_tokens(messages: str, model_name: str | None = None) -> int: ...
+
+
+@overload
+def count_tokens(
+    messages: Iterator[dict[str, str]], model_name: str | None = None, functions: Any | None = None
+) -> int: ...
+
+
+def count_tokens(
+    messages: Iterator[dict[str, str]] | str,
+    model_name: str | None = None,
+    functions: Any | None = None,
+) -> int:
+    if isinstance(messages, str):
+        tokenizer = get_tokenizer(model_name or DEFAULT_MODEL_NAME)
+        encoded = tokenizer.encode(messages)
+        return len(encoded)
+    return _count_messages_and_function_tokens(messages, model_name, functions)
+
+
+def _count_messages_and_function_tokens(
+    messages: Iterator[dict[str, str]], model_name: str | None = None, functions: Any | None = None
+) -> int:
+    """トークン数計測
+
+    Args:
+        messages (Messages): GPTAPIの入力のmessages
+        model_name (str | None, optional): モデル名. Defaults to None.
+        functions (Functions | None, optional): GPTAPIの入力のfunctions. Defaults to None.
+
+    Returns:
+        int: トークン数
+    """
+    num_tokens = _count_messages_tokens(messages, model_name or DEFAULT_MODEL_NAME)
+    if functions is not None:
+        num_tokens += _count_functions_tokens(functions, model_name)
+    return num_tokens
+
+
+# https://github.com/openai/openai-cookbook/blob/main/examples/How_to_count_tokens_with_tiktoken.ipynb
+def _count_messages_tokens(messages: Iterator[dict[str, str]] | None, model_name: str) -> int:
+    """メッセージのトークン数を計算
+
+    Args:
+        messages (Messages): ChatGPT等APIに入力するmessages
+        model_name (str, optional): 使用するモデルの名前
+            "gpt-3.5-turbo-0613", "gpt-3.5-turbo-16k-0613", "gpt-4-0314", "gpt-4-32k-0314"
+            "gpt-4-0613", "gpt-4-32k-0613", "gpt-3.5-turbo", "gpt-4"
+
+    Returns:
+        int: トークン数の合計
+    """
+    if messages is None:
+        return 0
+    # setting model
+    encoding_model = get_tokenizer(model_name)
+
+    # config
+    if "gpt-3.5-turbo-0301" in model_name:
+        tokens_per_message = 4  # every message follows <|start|>{role/name}\n{content}<|end|>\n
+        tokens_per_name = -1  # if there's a name, the role is omitted
+    else:
+        tokens_per_message = 3
+        tokens_per_name = 1
+
+    # count tokens
+    num_tokens = 3  # every reply is primed with <|start|>assistant<|message|>
+    for message in messages:
+        num_tokens += tokens_per_message
+        for key, value in message.items():
+            if isinstance(value, str):
+                num_tokens += len(encoding_model.encode(value))
+            if key == "name":
+                num_tokens += tokens_per_name
+    return num_tokens
+
+
+# https://gist.github.com/CGamesPlay/dd4f108f27e2eec145eedf5c717318f5
+def _count_functions_tokens(functions: Any, model_name: str | None = None) -> int:
+    """
+    functionsのトークン数計測
+
+    Args:
+        functions (Functions): GPTAPIの入力のfunctions
+        model_name (str | None, optional): モデル名. Defaults to None.
+
+    Returns:
+        _type_: トークン数
+    """
+    encoding_model = encoding_model = get_tokenizer(model_name or DEFAULT_MODEL_NAME)
+    num_tokens = 3 + len(encoding_model.encode(__functions2string(functions)))
+    return num_tokens
+
+
+# functionsのstring化、補助関数 ---------------------------------------------------------------------------
+def __functions2string(functions: Any) -> str:
+    """functionsの文字列化
+
+    Args:
+        functions (Functions): GPTAPIの入力のfunctions
+
+    Returns:
+        str: functionsの文字列
+    """
+    prefix = "# Tools\n\n## functions\n\nnamespace functions {\n\n} // namespace functions\n"
+    functions_string = prefix + "".join(__function2string(function) for function in functions)
+    return functions_string
+
+
+def __function2string(function: Function) -> str:
+    """functionの文字列化
+
+    Args:
+        function (Function): GPTAPIのfunctionの要素
+
+    Returns:
+        str: functionの文字列
+    """
+    object_string = __format_object(function["parameters"])
+    if object_string is not None:
+        object_string = "_: " + object_string
+    else:
+        object_string = ""
+
+    functions_string: str = (
+        f"// {function['description']}\ntype {function['name']} = (" + object_string + ") => any;\n\n"
+    )
+    return functions_string
+
+
+def __format_object(schema: dict[str, Any], indent: int = 0) -> str | None:
+    if "properties" not in schema or len(schema["properties"]) == 0:
+        if schema.get("additionalProperties", False):
+            return "object"
+        return None
+
+    result = "{\n"
+    for key, value in dict(schema["properties"]).items():
+        # value <- resolve_ref(value)
+        value_rendered = __format_schema(value, indent + 1)
+        if value_rendered is None:
+            continue
+        # description
+        if "description" in value:
+            description = "".join(
+                "  " * indent + f"// {description_i}\n"
+                for description_i in textwrap.dedent(value["description"]).strip().split("\n")
+            )
+        # optional
+        optional = "" if key in schema.get("required", {}) else "?"
+        # default
+        default_comment = "" if "default" not in value else f" // default: {__format_default(value)}"
+        # add string
+        result += description + "  " * indent + f"{key}{optional}: {value_rendered},{default_comment}\n"
+    result += ("  " * (indent - 1)) + "}"
+    return result
+
+
+# よくわからん
+# def resolve_ref(schema):
+#     if schema.get("$ref") is not None:
+#         ref = schema["$ref"][14:]
+#         schema = json_schema["definitions"][ref]
+#     return schema
+
+
+def __format_schema(schema: dict[str, Any], indent: int) -> str | None:
+    # schema <- resolve_ref(schema)
+    if "enum" in schema:
+        return __format_enum(schema)
+    elif schema["type"] == "object":
+        return __format_object(schema, indent)
+    elif schema["type"] in {"integer", "number"}:
+        return "number"
+    elif schema["type"] in {"string"}:
+        return "string"
+    elif schema["type"] == "array":
+        return str(__format_schema(schema["items"], indent)) + "[]"
+    else:
+        raise ValueError("unknown schema type " + schema["type"])
+
+
+def __format_enum(schema: dict[str, Any]) -> str:
+    # "A" | "B" | "C"
+    return " | ".join(json.dumps(element, ensure_ascii=False) for element in schema["enum"])
+
+
+def __format_default(schema: dict[str, Any]) -> str:
+    default = schema["default"]
+    if schema["type"] == "number" and float(default).is_integer():
+        # numberの時、0 → 0.0
+        return f"{default:.1f}"
+    else:
+        return str(default)

neollm/llm/platform.py

@@ -0,0 +1,16 @@
+from enum import Enum
+
+
+class Platform(str, Enum):
+    AZURE = "azure"
+    OPENAI = "openai"
+    ANTHROPIC = "anthropic"
+    GCP = "gcp"
+
+    @classmethod
+    def from_string(cls, platform: str) -> "Platform":
+        platform = platform.lower().strip()
+        try:
+            return cls(platform)
+        except Exception:
+            raise ValueError(f"platform must be {cls.__members__}, but got {platform}.")

neollm/llm/utils.py

@@ -0,0 +1,72 @@
+from typing import Any, TypeVar
+
+from neollm.utils.utils import cprint
+
+Immutable = tuple[Any, ...] | str | int | float | bool
+_T = TypeVar("_T")
+_TD = TypeVar("_TD")
+
+
+def _to_immutable(x: Any) -> Immutable:
+    """list, dictをtupleに変換して, setに格納できるようにする
+
+    Args:
+        x (Any): 要素
+
+    Returns:
+        Immutable: Immutableな要素(dict, listはtupleに変換)
+    """
+    if isinstance(x, list):
+        return tuple(map(_to_immutable, x))
+    if isinstance(x, dict):
+        return tuple((key, _to_immutable(value)) for key, value in sorted(x.items()))
+    if isinstance(x, (set, frozenset)):
+        return tuple(sorted(map(_to_immutable, x)))
+    if isinstance(x, (str, int, float, bool)):
+        return x
+    cprint("_to_immutable: not supported: 無理やりstr(*)", color="yellow", background=True)
+    return str(x)
+
+
+def _remove_duplicate(arr: list[_T | None]) -> list[_T]:
+    """listの重複と初期値を削除する
+
+    Args:
+        arr (list[Any]): リスト
+
+    Returns:
+        list[Any]: 重複削除済みのlist
+    """
+    seen_set: set[Immutable] = set()
+    unique_list: list[_T] = []
+    for x in arr:
+        if x is None or bool(x) is False:
+            continue
+        x_immutable = _to_immutable(x)
+        if x_immutable not in seen_set:
+            unique_list.append(x)
+            seen_set.add(x_immutable)
+    return unique_list
+
+
+def get_entity(arr: list[_T | None], default: _TD, index: int | None = None) -> _T | _TD:
+    """listから必要な1要素を取得する
+
+    Args:
+        arr (list[Any]): list
+        default (Any): 初期値
+        index (int | None, optional): 複数ある場合、指定のindex. Defaults to None.
+
+    Returns:
+        Any: 要素
+    """
+    arr_cleaned = _remove_duplicate(arr)
+    if len(arr_cleaned) == 0:
+        return default
+    if len(arr_cleaned) == 1:
+        return arr_cleaned[0]
+    if index is not None:
+        return arr_cleaned[index]
+    cprint("get_entity: not unique", color="yellow", background=True)
+    cprint(arr_cleaned, color="yellow", background=True)
+    return arr_cleaned[0]

neollm/myllm/abstract_myllm.py

@@ -0,0 +1,148 @@
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING, Generator, Generic, Optional, TypeAlias, cast
+
+from neollm.myllm.print_utils import print_inputs, print_metadata, print_outputs
+from neollm.types import (
+    InputType,
+    OutputType,
+    PriceInfo,
+    StreamOutputType,
+    TimeInfo,
+    TokenInfo,
+)
+from neollm.utils.utils import cprint
+
+if TYPE_CHECKING:
+    from typing import Any
+
+    from neollm.myllm.myl3m2 import MyL3M2
+
+    _MyL3M2: TypeAlias = MyL3M2[Any, Any]
+
+
+class AbstractMyLLM(ABC, Generic[InputType, OutputType]):
+    """MyLLM, MyL3M2の抽象クラス"""
+
+    inputs: InputType | None
+    outputs: OutputType | None
+    silent_set: set[str]
+    verbose: bool
+    time: float = 0.0
+    time_detail: TimeInfo = TimeInfo()
+    parent: Optional["_MyL3M2"] = None
+    do_stream: bool
+
+    @property
+    @abstractmethod
+    def token(self) -> TokenInfo:
+        """LLMの利用トークン数
+
+        Returns:
+            TokenInfo: トークン数 (入力, 出力, 合計)
+            >>> TokenInfo(input=1588, output=128, total=1716)
+        """
+
+    @property
+    def custom_token(self) -> TokenInfo | None:
+        """料金計算用トークン（Gemini用）"""
+        return None
+
+    @property
+    @abstractmethod
+    def price(self) -> PriceInfo:
+        """LLMの利用料金 (USD)
+
+        Returns:
+            PriceInfo: 利用料金 (USD) (入力, 出力, 合計)
+            >>> PriceInfo(input=0.002382, output=0.000256, total=0.002638)
+        """
+
+    @abstractmethod
+    def _call(self, inputs: InputType, stream: bool = False) -> Generator[StreamOutputType, None, OutputType]:
+        """MyLLMの子クラスのメインロジック
+
+        streamとnon-streamの両方のコードを書く必要がある
+
+        Args:
+            inputs (InputType): LLMへの入力
+            stream (bool, optional): streamの有無. Defaults to False.
+
+        Yields:
+            Generator[StreamOutputType, None, OutputType]: LLMのstream出力
+
+        Returns:
+            OutputType: LLMの出力
+        """
+
+    def __call__(self, inputs: InputType) -> OutputType:
+        """MyLLMのメインロジック
+
+        Args:
+            inputs (InputType): LLMへの入力
+
+        Returns:
+            OutputType: LLMの出力
+        """
+        it: Generator[StreamOutputType, None, OutputType] = self._call(inputs, stream=self.do_stream)
+        while True:
+            try:
+                next(it)
+            except StopIteration as e:
+                outputs = cast(OutputType, e.value)
+                return outputs
+            except Exception as e:
+                raise e
+
+    def call_stream(self, inputs: InputType) -> Generator[StreamOutputType, None, OutputType]:
+        """MyLLMのメインロジック(stream処理)
+
+        Args:
+            inputs (InputType): LLMへの入力
+
+        Yields:
+            Generator[StreamOutputType, None, OutputType]: LLMのstream出力
+
+        Returns:
+            LLMの出力
+        """
+        it: Generator[StreamOutputType, None, OutputType] = self._call(inputs, stream=True)
+        while True:
+            try:
+                delta_content = next(it)
+                yield delta_content
+            except StopIteration as e:
+                outputs = cast(OutputType, e.value)
+                return outputs
+            except Exception as e:
+                raise e
+
+    def _print_inputs(self) -> None:
+        if self.inputs is None:
+            return
+        if not ("inputs" not in self.silent_set and self.verbose):
+            return
+        print_inputs(self.inputs)
+
+    def _print_outputs(self) -> None:
+        if self.outputs is None:
+            return
+        if not ("outputs" not in self.silent_set and self.verbose):
+            return
+        print_outputs(self.outputs)
+
+    def _print_metadata(self) -> None:
+        if not ("metadata" not in self.silent_set and self.verbose):
+            return
+        print_metadata(self.time, self.token, self.price)
+
+    def _print_start(self, sep: str = "-") -> None:
+        if not self.verbose:
+            return
+        if self.parent is None:
+            cprint("PARENT", color="red", background=True)
+        print(self, sep * (99 - len(str(self))))
+
+    def _print_end(self, sep: str = "-") -> None:
+        if not self.verbose:
+            return
+        print(sep * 100)

neollm/myllm/myl3m2.py

@@ -0,0 +1,165 @@
+from __future__ import annotations
+
+import time
+from typing import Any, Generator, Literal, Optional, cast
+
+from neollm.myllm.abstract_myllm import AbstractMyLLM
+from neollm.myllm.myllm import MyLLM
+from neollm.myllm.print_utils import TITLE_COLOR
+from neollm.types import (
+    InputType,
+    OutputType,
+    PriceInfo,
+    StreamOutputType,
+    TimeInfo,
+    TokenInfo,
+)
+from neollm.utils.utils import cprint
+
+
+class MyL3M2(AbstractMyLLM[InputType, OutputType]):
+    """LLMの複数リクエストをまとめるクラス"""
+
+    do_stream: bool = False  # stream_verboseがないため、__call__ではstreamを使わない
+
+    def __init__(
+        self,
+        parent: Optional["MyL3M2[Any, Any]"] = None,
+        verbose: bool = False,
+        silent_list: list[Literal["inputs", "outputs", "metadata", "all_myllm"]] | None = None,
+    ) -> None:
+        """
+        MyL3M2の初期化
+
+        Args:
+            parent (MyL3M2, optional):
+                親のMyL3M2のインスタンス(self or None)
+            verbose (bool, optional):
+                出力をするかどうかのフラグ. Defaults to False.
+            sileznt_list (list[Literal["inputs", "outputs", "metadata", "all_myllm"]], optional):
+                サイレントモードのリスト。出力を抑制する要素を指定する。. Defaults to None(=[]).
+        """
+        self.parent = parent
+        self.verbose = verbose
+        self.silent_set = set(silent_list or [])
+        self.myllm_list: list["MyL3M2[Any, Any]" | MyLLM[Any, Any]] = []
+        self.inputs: InputType | None = None
+        self.outputs: OutputType | None = None
+        self.called: bool = False
+
+    def _link(self, inputs: InputType) -> OutputType:
+        """複数のLLMの処理を行う
+
+        Args:
+            inputs (InputType): 入力データを保持する辞書
+
+        Returns:
+            OutputType: 処理結果の出力データ
+        """
+        raise NotImplementedError("_link(self, inputs: InputType) -> OutputType:を実装してください")
+
+    def _stream_link(self, inputs: InputType) -> Generator[StreamOutputType, None, OutputType]:
+        """複数のLLMの処理を行う(stream処理)
+
+        Args:
+            inputs (InputType): 入力データを保持する辞書
+
+        Yields:
+            Generator[StreamOutputType, None, OutputType]: 処理結果の出力データ(stream)
+
+        Returns:
+            self.outputsに入れたいもの
+        """
+        raise NotImplementedError(
+            "_stream_link(self, inputs: InputType) -> Generator[StreamOutputType, None, None]を実装してください"
+        )
+
+    def _call(self, inputs: InputType, stream: bool = False) -> Generator[StreamOutputType, None, OutputType]:
+        if self.called:
+            raise RuntimeError("MyLLMは1回しか呼び出せない")
+
+        self._print_start(sep="=")
+
+        # main -----------------------------------------------------------
+        t_start = time.time()
+        self.inputs = inputs
+        # [stream]
+        if stream:
+            it = self._stream_link(inputs)
+            while True:
+                try:
+                    yield next(it)
+                except StopIteration as e:
+                    self.outputs = cast(OutputType, e.value)
+                    break
+                except Exception as e:
+                    raise e
+        # [non-stream]
+        else:
+            self.outputs = self._link(inputs)
+        self._print_inputs()
+        self._print_outputs()
+        self._print_all_myllm()
+        self.time = time.time() - t_start
+        self.time_detail = TimeInfo(total=self.time, main=self.time)
+
+        # metadata -----------------------------------------------------------
+        self._print_metadata()
+        self._print_end(sep="=")
+
+        # 親MyL3M2にAppend -----------------------------------------------------------
+        if self.parent is not None:
+            self.parent.myllm_list.append(self)
+        self.called = True
+
+        return self.outputs
+
+    @property
+    def token(self) -> TokenInfo:
+        token = TokenInfo(input=0, output=0, total=0)
+        for myllm in self.myllm_list:
+            # TODO:  token += myllm.token
+            token.input += myllm.token.input
+            token.output += myllm.token.output
+            token.total += myllm.token.total
+        return token
+
+    @property
+    def price(self) -> PriceInfo:
+        price = PriceInfo(input=0.0, output=0.0, total=0.0)
+        for myllm in self.myllm_list:
+            # TODO: price += myllm.price
+            price.input += myllm.price.input
+            price.output += myllm.price.output
+            price.total += myllm.price.total
+        return price
+
+    @property
+    def logs(self) -> list[Any]:
+        logs: list[Any] = []
+        for myllm in self.myllm_list:
+            if isinstance(myllm, MyLLM):
+                logs.append(myllm.log)
+            elif isinstance(myllm, MyL3M2):
+                logs.extend(myllm.logs)
+        return logs
+
+    def _print_all_myllm(self, prefix: str = "", title: bool = True) -> None:
+        if not ("all_myllm" not in self.silent_set and self.verbose):
+            return
+        try:
+            if title:
+                cprint("[all_myllm]", color=TITLE_COLOR)
+                print("  ", end="")
+                cprint(f"{self}", color="magenta", bold=True, underline=True)
+            for myllm in self.myllm_list:
+                if isinstance(myllm, MyLLM):
+                    cprint(f"    {prefix}- {myllm}", color="cyan")
+                elif isinstance(myllm, MyL3M2):
+                    cprint(f"    {prefix}- {myllm}", color="magenta")
+                    myllm._print_all_myllm(prefix=prefix + "  ", title=False)
+        except Exception as e:
+            cprint(e, color="red", background=True)
+
+    def __repr__(self) -> str:
+        return f"MyL3M2({self.__class__.__name__})"

neollm/myllm/myllm.py

@@ -0,0 +1,449 @@
+import os
+import time
+from abc import abstractmethod
+from typing import TYPE_CHECKING, Any, Final, Generator, Literal, Optional
+
+from neollm.exceptions import ContentFilterError
+from neollm.llm import AbstractLLM, get_llm
+from neollm.llm.gpt.azure_llm import AzureLLM
+from neollm.myllm.abstract_myllm import AbstractMyLLM
+from neollm.myllm.print_utils import (
+    print_client_settings,
+    print_delta,
+    print_llm_settings,
+    print_messages,
+)
+from neollm.types import (
+    Chunk,
+    ClientSettings,
+    Functions,
+    InputType,
+    LLMSettings,
+    Message,
+    Messages,
+    OutputType,
+    PriceInfo,
+    Response,
+    StreamOutputType,
+    TimeInfo,
+    TokenInfo,
+    Tools,
+)
+from neollm.types.openai.chat_completion import CompletionUsageForCustomPriceCalculation
+from neollm.utils.preprocess import dict2json
+from neollm.utils.utils import cprint
+
+if TYPE_CHECKING:
+    from neollm.myllm.myl3m2 import MyL3M2
+
+    _MyL3M2 = MyL3M2[Any, Any]
+    _State = dict[Any, Any]
+
+DEFAULT_LLM_SETTINGS: LLMSettings = {"temperature": 0}
+DEFAULT_PLATFORM: Final[str] = "azure"
+
+
+class MyLLM(AbstractMyLLM[InputType, OutputType]):
+    """LLMの単一リクエストをまとめるクラス"""
+
+    def __init__(
+        self,
+        model: str,
+        parent: Optional["_MyL3M2"] = None,
+        llm_settings: LLMSettings | None = None,
+        client_settings: ClientSettings | None = None,
+        platform: str | None = None,
+        verbose: bool = False,
+        stream_verbose: bool = False,
+        silent_list: list[Literal["llm_settings", "inputs", "outputs", "messages", "metadata"]] | None = None,
+        log_dir: str | None = None,
+    ) -> None:
+        """
+        MyLLMクラスの初期化
+
+        Args:
+            model (Optional[str]): LLMモデル名
+            parent (Optional[MyL3M2]): 親のMyL3M2のインスタンス (self or None)
+            llm_settings (LLMSettings): LLMの設定パラメータ
+            client_settings (ClientSettings): llmのclientの設定パラメータ
+            platform (Optional[str]): LLMのプラットフォーム名 (デフォルト: os.environ["PLATFORM"] or "azure")
+                (enum: openai, azure)
+            verbose (bool): 出力をするかどうかのフラグ
+            stream_verbose (bool): assitantをstreamで出力するか(verbose=False, message in "messages"の時、無効)
+            silent_list (list[Literal["llm_settings", "inputs", "outputs", "messages", "metadata"]]):
+                verbose=True時, 出力を抑制する要素のリスト
+            log_dir (Optional[str]): ログを保存するディレクトリのパス Noneの時、保存しない
+        """
+        self.parent: _MyL3M2 | None = parent
+        self.llm_settings = llm_settings or DEFAULT_LLM_SETTINGS
+        self.client_settings = client_settings or {}
+        self.model: str = model
+        self.platform: str = platform or os.environ.get("LLM_PLATFORM", DEFAULT_PLATFORM) or DEFAULT_PLATFORM
+        self.verbose: bool = verbose & (True if self.parent is None else self.parent.verbose)  # 親に合わせる
+        self.silent_set = set(silent_list or [])
+        self.stream_verbose: bool = stream_verbose if verbose and ("messages" not in self.silent_set) else False
+        self.log_dir: str | None = log_dir
+
+        self.inputs: InputType | None = None
+        self.outputs: OutputType | None = None
+        self.messages: Messages | None = None
+        self.functions: Functions | None = None
+        self.tools: Tools | None = None
+        self.response: Response | None = None
+        self.called: bool = False
+        self.do_stream: bool = self.stream_verbose
+
+        self.llm: AbstractLLM = get_llm(
+            model_name=self.model, platform=self.platform, client_settings=self.client_settings
+        )
+
+    @abstractmethod
+    def _preprocess(self, inputs: InputType) -> Messages:
+        """
+        inputs を API入力 の messages に前処理する
+
+        Args:
+            inputs (InputType): 入力
+
+        Returns:
+            Messages: API入力 の messages
+            >>> [{"role": "system", "content": "system_prompt"}, {"role": "user", "content": "user_prompt"}]
+        """
+
+    @abstractmethod
+    def _postprocess(self, response: Response) -> OutputType:
+        """
+        API の response を outputs に後処理する
+
+        Args:
+            response (Response): API の response
+            >>> {"choices": [{"message": {"role": "assistant",
+            >>>                           "content": "This is a test!"}}]}
+            >>> {"choices": [{"message": {"role": "assistant",
+            >>>                           "function_call": {"name": "func", "arguments": "{a: 1}"}}]}
+
+        Returns:
+            OutputType: 出力
+        """
+
+    def _ruleprocess(self, inputs: InputType) -> OutputType | None:
+        """
+        ルールベース処理 or APIリクエスト の判断
+
+        Args:
+            inputs (InputType): MyLLMの入力
+
+        Returns:
+            RuleOutputs:
+                ルールベース処理の時、MyLLMの出力を返す
+                APIリクエストの時、Noneを返す
+        """
+        return None
+
+    def _update_settings(self) -> None:
+        """
+        APIの設定の更新
+        Note:
+            messageのトークン数
+            >>> self.llm.count_tokens(self.messsage)
+
+            モデル変更
+            >>> self.model = "gpt-3.5-turbo-16k"
+
+            パラメータ変更
+            >>> self.llm_settings = {"temperature": 0.2}
+        """
+        return None
+
+    def _add_tools(self, inputs: InputType) -> Tools | None:
+        return None
+
+    def _add_functions(self, inputs: InputType) -> Functions | None:
+        """
+        functions の追加
+
+        Args:
+            inputs (InputType): 入力
+
+        Returns:
+            Functions | None: functions。追加しない場合None
+            https://json-schema.org/understanding-json-schema/reference/index.html
+            >>> {
+            >>>     "name": "関数名",
+            >>>     "description": "関数の動作の説明。GPTは説明を見て利用するか選ぶ",
+            >>>     "parameters": {
+            >>>         "type": "object", "properties": {"city_name": {"type": "string", "description": "都市名"}},
+            >>>         json-schema[https://json-schema.org/understanding-json-schema/reference/index.html]
+            >>>     }
+            >>> }
+        """
+        return None
+
+    def _stream_postprocess(
+        self,
+        new_chunk: Chunk,
+        state: "_State",
+    ) -> StreamOutputType:
+        """call_streamのGeneratorのpostprocess
+
+        Args:
+            new_chunk (OpenAIChunkResponse): 新しいchunk
+            state (dict[Any, Any]): 状態を持てるdict. 初めは、default {}. 状態が消えてしまうのでoverwriteしない。
+
+        Returns:
+            StreamOutputType: 一時的なoutput
+        """
+        if len(new_chunk.choices) == 0:
+            return ""
+        return new_chunk.choices[0].delta.content
+
+    def _generate(self, stream: bool) -> Generator[StreamOutputType, None, None]:
+        """
+        LLMの出力を得て、`self.response`に格納する
+
+        Args:
+            messages (list[dict[str, str]]): LLMの入力メッセージ
+        """
+        # 例外処理 -----------------------------------------------------------
+        if self.messages is None:
+            raise ValueError("MessagesがNoneです。")
+
+        # kwargs -----------------------------------------------------------
+        generate_kwargs = dict(**self.llm_settings)
+        if self.functions is not None:
+            generate_kwargs["functions"] = self.functions
+        if self.functions is not None:
+            generate_kwargs["tools"] = self.tools
+
+        # generate ----------------------------------------------------------
+        self._print_messages()  # verbose
+        self.llm = get_llm(model_name=self.model, platform=self.platform, client_settings=self.client_settings)
+        # [stream]
+        if stream or self.stream_verbose:
+            it = self.llm.generate_stream(messages=self.messages, llm_settings=generate_kwargs)
+            chunk_list: list[Chunk] = []
+            state: "_State" = {}
+            for chunk in it:
+                chunk_list.append(chunk)
+                self._print_delta(chunk=chunk)  # verbose: stop→改行、conent, TODO: fc→出力
+                yield self._stream_postprocess(new_chunk=chunk, state=state)
+            self.response = self.llm.convert_nonstream_response(chunk_list, self.messages, self.functions)
+        # [non-stream]
+        else:
+            try:
+                self.response = self.llm.generate(messages=self.messages, llm_settings=generate_kwargs)
+                self._print_message_assistant()
+            except Exception as e:
+                raise e
+
+        # ContentFilterError -------------------------------------------------
+        if len(self.response.choices) == 0:
+            cprint(self.response, color="red", background=True)
+            raise ContentFilterError("入力のコンテンツフィルターに引っかかりました。")
+        if self.response.choices[0].finish_reason == "content_filter":
+            cprint(self.response, color="red", background=True)
+            raise ContentFilterError("出力のコンテンツフィルターに引っかかりました。")
+
+    def _call(self, inputs: InputType, stream: bool = False) -> Generator[StreamOutputType, None, OutputType]:
+        """
+        LLMの処理を行う (preprocess, check_input, generate, postprocess)
+
+        Args:
+            inputs (InputType): 入力データを保持する辞書
+
+        Returns:
+            OutputType: 処理結果の出力データ
+
+        Raises:
+            RuntimeError: 既に呼び出されている場合に発生
+        """
+        if self.called:
+            raise RuntimeError("MyLLMは1回しか呼び出せない")
+
+        self._print_start(sep="-")
+
+        # main -----------------------------------------------------------
+        t_start = time.time()
+        self.inputs = inputs
+        self._print_inputs()
+        rulebase_output = self._ruleprocess(inputs)
+        if rulebase_output is None:  # API リクエストを送る場合
+            self._update_settings()
+            self.messages = self._preprocess(inputs)
+            self.functions = self._add_functions(inputs)
+            self.tools = self._add_tools(inputs)
+            t_preprocessed = time.time()
+            # [generate]
+            it = self._generate(stream=stream)
+            for delta_content in it:  # stream=Falseの時、空のGenerator
+                yield delta_content
+            if self.response is None:
+                raise ValueError("responseがNoneです。")
+            t_generated = time.time()
+            # [postprocess]
+            self.outputs = self._postprocess(self.response)
+            t_postprocessed = time.time()
+        else:  # ルールベースの場合
+            self.outputs = rulebase_output
+            t_preprocessed = t_generated = t_postprocessed = time.time()
+        self.time_detail = TimeInfo(
+            total=t_postprocessed - t_start,
+            preprocess=t_preprocessed - t_start,
+            main=t_generated - t_preprocessed,
+            postprocess=t_postprocessed - t_generated,
+        )
+        self.time = t_postprocessed - t_start
+
+        # print -----------------------------------------------------------
+        self._print_outputs()
+        self._print_client_settings()
+        self._print_llm_settings()
+        self._print_metadata()
+        self._print_end(sep="-")
+
+        # 親MyL3M2にAppend -----------------------------------------------------------
+        if self.parent is not None:
+            self.parent.myllm_list.append(self)
+        self.called = True
+
+        # log -----------------------------------------------------------
+        self._save_log()
+
+        return self.outputs
+
+    @property
+    def log(self) -> dict[str, Any]:
+        return {
+            "inputs": self.inputs,
+            "outputs": self.outputs,
+            "resposnse": self.response.model_dump() if self.response is not None else None,
+            "input_token": self.token.input,
+            "output_token": self.token.output,
+            "total_token": self.token.total,
+            "input_price": self.price.input,
+            "output_price": self.price.output,
+            "total_price": self.price.total,
+            "time": self.time,
+            "time_stamp": time.time(),
+            "llm_settings": self.llm_settings,
+            "client_settings": self.client_settings,
+            "model": self.model,
+            "platform": self.platform,
+            "verbose": self.verbose,
+            "messages": self.messages,
+            "assistant_message": self.assistant_message,
+            "functions": self.functions,
+            "tools": self.tools,
+        }
+
+    def _save_log(self) -> None:
+        if self.log_dir is None:
+            return
+        try:
+            log = self.log
+            json_string = dict2json(log)
+
+            save_log_path = os.path.join(self.log_dir, f"{log['time_stamp']}.json")
+            os.makedirs(self.log_dir, exist_ok=True)
+            with open(save_log_path, mode="w") as f:
+                f.write(json_string)
+        except Exception as e:
+            cprint(e, color="red", background=True)
+
+    @property
+    def token(self) -> TokenInfo:
+        if self.response is None or self.response.usage is None:
+            return TokenInfo(input=0, output=0, total=0)
+        return TokenInfo(
+            input=self.response.usage.prompt_tokens,
+            output=self.response.usage.completion_tokens,
+            total=self.response.usage.total_tokens,
+        )
+
+    @property
+    def custom_token(self) -> TokenInfo | None:
+        if not self.llm._custom_price_calculation:
+            return None
+        if self.response is None:
+            return TokenInfo(input=0, output=0, total=0)
+        usage_for_price = getattr(self.response, "usage_for_price", None)
+        if not isinstance(usage_for_price, CompletionUsageForCustomPriceCalculation):
+            cprint("usage_for_priceがNoneです。正しくトークン計算できません", color="red", background=True)
+            return TokenInfo(input=0, output=0, total=0)
+        return TokenInfo(
+            input=usage_for_price.prompt_tokens,
+            output=usage_for_price.completion_tokens,
+            total=usage_for_price.total_tokens,
+        )
+
+    @property
+    def price(self) -> PriceInfo:
+        if self.response is None:
+            return PriceInfo(input=0.0, output=0.0, total=0.0)
+        if self.llm._custom_price_calculation:
+            # Geniniの時は必ずcustom_tokenがある想定
+            if self.custom_token is None:
+                cprint("custom_tokenがNoneです。正しくトークン計算できません", color="red", background=True)
+            else:
+                return PriceInfo(
+                    input=self.llm.calculate_price(num_input_tokens=self.custom_token.input),
+                    output=self.llm.calculate_price(num_output_tokens=self.custom_token.output),
+                    total=self.llm.calculate_price(
+                        num_input_tokens=self.custom_token.input, num_output_tokens=self.custom_token.output
+                    ),
+                )
+        return PriceInfo(
+            input=self.llm.calculate_price(num_input_tokens=self.token.input),
+            output=self.llm.calculate_price(num_output_tokens=self.token.output),
+            total=self.llm.calculate_price(num_input_tokens=self.token.input, num_output_tokens=self.token.output),
+        )
+
+    @property
+    def assistant_message(self) -> Message | None:
+        if self.response is None or len(self.response.choices) == 0:
+            return None
+        return self.response.choices[0].message.to_typeddict_message()
+
+    @property
+    def chat_history(self) -> Messages:
+        chat_history: Messages = []
+        if self.messages:
+            chat_history += self.messages
+        if self.assistant_message is not None:
+            chat_history.append(self.assistant_message)
+        return chat_history
+
+    def _print_llm_settings(self) -> None:
+        if not ("llm_settings" not in self.silent_set and self.verbose):
+            return
+        print_llm_settings(
+            llm_settings=self.llm_settings,
+            model=self.model,
+            platform=self.platform,
+            engine=self.llm.engine if isinstance(self.llm, AzureLLM) else None,
+        )
+
+    def _print_messages(self) -> None:
+        if not ("messages" not in self.silent_set and self.verbose):
+            return
+        print_messages(self.messages, title=True)
+
+    def _print_message_assistant(self) -> None:
+        if self.response is None or len(self.response.choices) == 0:
+            return
+        if not ("messages" not in self.silent_set and self.verbose):
+            return
+        print_messages(messages=[self.response.choices[0].message], title=False)
+
+    def _print_delta(self, chunk: Chunk) -> None:
+        if not ("messages" not in self.silent_set and self.verbose):
+            return
+        print_delta(chunk)
+
+    def _print_client_settings(self) -> None:
+        if not ("client_settings" not in self.silent_set and self.verbose):
+            return
+        print_client_settings(self.llm.client_settings)
+
+    def __repr__(self) -> str:
+        return f"MyLLM({self.__class__.__name__})"

neollm/myllm/print_utils.py

@@ -0,0 +1,235 @@
+import json
+from typing import Any
+
+from openai.types.chat import ChatCompletionAssistantMessageParam
+from openai.types.chat.chat_completion_assistant_message_param import FunctionCall
+from openai.types.chat.chat_completion_message_tool_call_param import (
+    ChatCompletionMessageToolCallParam,
+    Function,
+)
+
+from neollm.types import (
+    ChatCompletionMessage,
+    Chunk,
+    ClientSettings,
+    InputType,
+    LLMSettings,
+    Message,
+    Messages,
+    OutputType,
+    PriceInfo,
+    PrintColor,
+    Role,
+    TokenInfo,
+)
+from neollm.utils.postprocess import json2dict
+from neollm.utils.utils import CPrintParam, cprint
+
+TITLE_COLOR: PrintColor = "blue"
+YEN_PAR_DOLLAR: float = 140.0  # 150円になってしまったぴえん(231027)
+
+
+def _ChatCompletionMessage2dict(message: ChatCompletionMessage) -> Message:
+    message_dict = ChatCompletionAssistantMessageParam(content=message.content, role=message.role)
+    if message.function_call is not None:
+        message_dict["function_call"] = FunctionCall(
+            arguments=message.function_call.arguments, name=message.function_call.name
+        )
+    if message.tool_calls is not None:
+        message_dict["tool_calls"] = [
+            ChatCompletionMessageToolCallParam(
+                id=tool_call.id,
+                function=Function(arguments=tool_call.function.arguments, name=tool_call.function.name),
+                type=tool_call.type,
+            )
+            for tool_call in message.tool_calls
+        ]
+    return message_dict
+
+
+def _get_tool_calls(message_dict: Message) -> list[ChatCompletionMessageToolCallParam]:
+    tool_calls: list[ChatCompletionMessageToolCallParam] = []
+    if "tool_calls" in message_dict:
+        _tool_calls = message_dict.get("tool_calls", None)
+        if _tool_calls is not None and isinstance(_tool_calls, list):  # isinstance(_tool_calls, list)ないと通らん,,,
+            for _tool_call in _tool_calls:
+                tool_call = ChatCompletionMessageToolCallParam(
+                    id=_tool_call["id"],
+                    function=Function(
+                        arguments=_tool_call["function"]["arguments"],
+                        name=_tool_call["function"]["name"],
+                    ),
+                    type=_tool_call["type"],
+                )
+                tool_calls.append(tool_call)
+    if "function_call" in message_dict:
+        function_call = message_dict.get("function_call", None)
+        if function_call is not None and isinstance(
+            function_call, dict
+        ):  # isinstance(function_call, dict)ないと通らん,,,
+            tool_calls.append(
+                ChatCompletionMessageToolCallParam(
+                    id="",
+                    function=Function(
+                        arguments=function_call["arguments"],
+                        name=function_call["name"],
+                    ),
+                    type="function",
+                )
+            )
+    return tool_calls
+
+
+def print_metadata(time: float, token: TokenInfo, price: PriceInfo) -> None:
+    try:
+        cprint("[metadata]", color=TITLE_COLOR, kwargs={"end": " "})
+        print(
+            f"{time:.1f}s; "
+            f"{token.total:,}({token.input:,}+{token.output:,})tokens; "
+            f"${price.total:.2g}; ¥{price.total*YEN_PAR_DOLLAR:.2g}"
+        )
+    except Exception as e:
+        cprint(e, color="red", background=True)
+
+
+def print_inputs(inputs: InputType) -> None:
+    try:
+        cprint("[inputs]", color=TITLE_COLOR)
+        print(json.dumps(_arange_dumpable_object(inputs), indent=2, ensure_ascii=False))
+    except Exception as e:
+        cprint(e, color="red", background=True)
+
+
+def print_outputs(outputs: OutputType) -> None:
+    try:
+        cprint("[outputs]", color=TITLE_COLOR)
+        print(json.dumps(_arange_dumpable_object(outputs), indent=2, ensure_ascii=False))
+    except Exception as e:
+        cprint(e, color="red", background=True)
+
+
+def print_messages(messages: list[ChatCompletionMessage] | Messages | None, title: bool = True) -> None:
+    if messages is None:
+        cprint("Not yet running _preprocess", color="red")
+        return
+    # try:
+    if title:
+        cprint("[messages]", color=TITLE_COLOR)
+    role2prarams: dict[Role, CPrintParam] = {
+        "system": {"color": "green"},
+        "user": {"color": "green"},
+        "assistant": {"color": "green"},
+        "function": {"color": "green", "background": True},
+        "tool": {"color": "green", "background": True},
+    }
+    for message in messages:
+        message_dict: Message
+        if isinstance(message, ChatCompletionMessage):
+            message_dict = _ChatCompletionMessage2dict(message)
+        else:
+            message_dict = message
+
+        # roleの出力 ----------------------------------------
+        print(" ", end="")
+        role = message_dict["role"]
+        cprint(role, **role2prarams[role])
+
+        # contentの出力 ----------------------------------------
+        content = message_dict.get("content", None)
+        if isinstance(content, str):
+            print("  " + content.replace("\n", "\n  "))
+        elif isinstance(content, list):
+            for content_part in content:
+                if content_part["type"] == "text":
+                    print("  " + content_part["text"].replace("\n", "\n  "))
+                elif content_part["type"] == "image_url":
+                    cprint("  <image_url>", color="green", kwargs={"end": " "})
+                    print(content_part["image_url"])
+                    # TODO: 画像出力
+                    # TODO: Preview用、content_part["image"]: str, dict両方いけてしまう
+                else:
+                    # TODO: 未対応のcontentの出力
+                    pass
+
+        # tool_callの出力 ----------------------------------------
+        for tool_call in _get_tool_calls(message_dict):
+            print(" ", end="")
+            cprint(tool_call["function"]["name"], color="green", background=True)
+            print("  " + str(json2dict(tool_call["function"]["arguments"], error_key=None)).replace("\n", "\n    "))
+
+    # except Exception as e:
+    #     cprint(e, color="red", background=True)
+
+
+def print_delta(chunk: Chunk) -> None:
+    if len(chunk.choices) == 0:
+        return
+    choice = chunk.choices[0]  # TODO: n>2の対応
+    if choice.delta.role is not None:
+        print(" ", end="")
+        cprint(choice.delta.role, color="green")
+        print("  ", end="")
+    if choice.delta.content is not None:
+        print(choice.delta.content.replace("\n", "\n  "), end="")
+    if choice.delta.function_call is not None:
+        if choice.delta.function_call.name is not None:
+            cprint(choice.delta.function_call.name, color="green", background=True)
+            print("  ", end="")
+        if choice.delta.function_call.arguments is not None:
+            print(choice.delta.function_call.arguments.replace("\n", "\n  "), end="")
+    if choice.delta.tool_calls is not None:
+        for tool_call in choice.delta.tool_calls:
+            if tool_call.function is not None:
+                if tool_call.function.name is not None:
+                    if tool_call.index != 0:
+                        print("\n  ", end="")
+                    cprint(tool_call.function.name, color="green", background=True)
+                    print("  ", end="")
+                if tool_call.function.arguments is not None:
+                    print(tool_call.function.arguments.replace("\n", "\n  "), end="")
+    if choice.finish_reason is not None:
+        print()
+
+
+def print_llm_settings(llm_settings: LLMSettings, model: str, engine: str | None, platform: str) -> None:
+    try:
+        cprint("[llm_settings]", color=TITLE_COLOR, kwargs={"end": " "})
+        llm_settings_copy = dict(platform=platform, **llm_settings)
+        llm_settings_copy["model"] = model
+        # Azureの場合
+        if platform == "azure":
+            llm_settings_copy["engine"] = engine  # engineを追加
+        print(llm_settings_copy or "-")
+    except Exception as e:
+        cprint(e, color="red", background=True)
+
+
+def print_client_settings(client_settings: ClientSettings) -> None:
+    try:
+        cprint("[client_settings]", color=TITLE_COLOR, kwargs={"end": " "})
+        print(client_settings or "-")
+    except Exception as e:
+        cprint(e, color="red", background=True)
+
+
+# -------
+
+_DumplableEntity = int | float | str | bool | None | list[Any] | dict[Any, Any]
+DumplableType = _DumplableEntity | list["DumplableType"] | dict["DumplableType", "DumplableType"]
+
+
+def _arange_dumpable_object(obj: Any) -> DumplableType:
+    # 基本データ型の場合、そのまま返す
+    if isinstance(obj, (int, float, str, bool, type(None))):
+        return obj
+
+    # リストの場合、再帰的に各要素を変換
+    if isinstance(obj, list):
+        return [_arange_dumpable_object(item) for item in obj]
+
+    # 辞書の場合、再帰的に各キーと値を変換
+    if isinstance(obj, dict):
+        return {_arange_dumpable_object(key): _arange_dumpable_object(value) for key, value in obj.items()}
+
+    # それ以外の型の場合、型情報を含めて文字列に変換
+    return f"<{type(obj).__name__}>{str(obj)}"

neollm/types/__init__.py

@@ -0,0 +1,4 @@
+from neollm.types.info import *  # NOQA
+from neollm.types.mytypes import *  # NOQA
+from neollm.types.openai.chat_completion import *  # NOQA
+from neollm.types.openai.chat_completion_chunk import *  # NOQA

neollm/types/_model.py

@@ -0,0 +1,8 @@
+from typing import Any
+
+from openai._models import BaseModel
+
+
+class DictableBaseModel(BaseModel):  # openaiのBaseModelをDictAccessできるようにした
+    def __getitem__(self, item: str) -> Any:
+        return getattr(self, item)

neollm/types/info.py

@@ -0,0 +1,82 @@
+from typing import Literal
+
+from neollm.types._model import DictableBaseModel
+
+PrintColor = Literal["black", "red", "green", "yellow", "blue", "magenta", "cyan", "white"]
+
+
+class TimeInfo(DictableBaseModel):
+    total: float = 0.0
+    """処理時間合計 preprocess + main + postprocess"""
+    preprocess: float = 0.0
+    """前処理時間"""
+    main: float = 0.0
+    """メイン処理時間"""
+    postprocess: float = 0.0
+    """後処理時間"""
+
+    def __repr__(self) -> str:
+        return (
+            f"TimeInfo(total={self.total:.3f}, preprocess={self.preprocess:.3f}, main={self.main:.3f}, "
+            f"postprocess={self.postprocess:.3f})"
+        )
+
+
+class TokenInfo(DictableBaseModel):
+    input: int
+    """入力部分のトークン数"""
+    output: int
+    """出力部分のトークン数"""
+    total: int
+    """合計トークン数"""
+
+    def __add__(self, other: "TokenInfo") -> "TokenInfo":
+        if not isinstance(other, TokenInfo):
+            raise TypeError(f"{other} is not TokenInfo")
+        return TokenInfo(
+            input=self.input + other.input, output=self.output + other.output, total=self.total + other.total
+        )
+
+    def __iadd__(self, other: "TokenInfo") -> "TokenInfo":
+        if not isinstance(other, TokenInfo):
+            raise TypeError(f"{other} is not TokenInfo")
+        self.input += other.input
+        self.output += other.output
+        self.total += other.total
+        return self
+
+
+class PriceInfo(DictableBaseModel):
+    input: float
+    """入力部分の費用 (USD)"""
+    output: float
+    """出力部分の費用 (USD)"""
+    total: float
+    """合計費用 (USD)"""
+
+    def __add__(self, other: "PriceInfo") -> "PriceInfo":
+        if not isinstance(other, PriceInfo):
+            raise TypeError(f"{other} is not PriceInfo")
+        return PriceInfo(
+            input=self.input + other.input, output=self.output + other.output, total=self.total + other.total
+        )
+
+    def __iadd__(self, other: "PriceInfo") -> "PriceInfo":
+        if not isinstance(other, PriceInfo):
+            raise TypeError(f"{other} is not PriceInfo")
+        self.input += other.input
+        self.output += other.output
+        self.total += other.total
+        return self
+
+    def __repr__(self) -> str:
+        return f"PriceInfo(input={self.input:.3f}, output={self.output:.3f}, total={self.total:.3f})"
+
+
+class APIPricing(DictableBaseModel):
+    """APIの価格設定に関する情報を表すクラス。"""
+
+    input: float
+    """入力 1k tokens 当たりのAPI利用料 (USD)"""
+    output: float
+    """出力 1k tokens 当たりのAPI利用料 (USD)"""

neollm/types/mytypes.py

@@ -0,0 +1,31 @@
+from typing import Any, Iterator, Literal, TypeVar
+
+import openai.types.chat as openai_types
+from openai._streaming import Stream
+
+from neollm.types.openai.chat_completion import ChatCompletion
+from neollm.types.openai.chat_completion_chunk import ChatCompletionChunk
+
+Role = Literal["system", "user", "assistant", "tool", "function"]
+# Settings
+LLMSettings = dict[str, Any]
+ClientSettings = dict[str, Any]
+# Message
+Message = openai_types.ChatCompletionMessageParam
+Messages = list[Message]
+Tools = Any
+Functions = Any
+# Response
+Response = ChatCompletion
+Chunk = ChatCompletionChunk
+StreamResponse = Iterator[Chunk]
+# IO
+InputType = TypeVar("InputType")
+OutputType = TypeVar("OutputType")
+StreamOutputType = Any
+
+# OpenAI --------------------------------------------
+OpenAIResponse = openai_types.ChatCompletion
+OpenAIChunk = openai_types.ChatCompletionChunk
+OpenAIStreamResponse = Stream[OpenAIChunk]  # OpneAI StreamResponse
+OpenAIMessages = list[openai_types.ChatCompletionMessageParam]

neollm/types/openai/__init__.py

@@ -0,0 +1,2 @@
+from neollm.types.openai.chat_completion import *  # NOQA
+from neollm.types.openai.chat_completion_chunk import *  # NOQA

neollm/types/openai/chat_completion.py

@@ -0,0 +1,170 @@
+from typing import List, Literal, Optional
+
+from openai.types.chat import ChatCompletionAssistantMessageParam
+from openai.types.chat.chat_completion_assistant_message_param import (
+    FunctionCall as FunctionCallParams,
+)
+from openai.types.chat.chat_completion_message_tool_call_param import (
+    ChatCompletionMessageToolCallParam,
+)
+from openai.types.chat.chat_completion_message_tool_call_param import (
+    Function as FunctionParams,
+)
+from pydantic import field_validator
+
+from neollm.types._model import DictableBaseModel
+
+
+class CompletionUsage(DictableBaseModel):
+    completion_tokens: int
+    """Number of tokens in the generated completion."""
+
+    prompt_tokens: int
+    """Number of tokens in the prompt."""
+
+    total_tokens: int
+    """Total number of tokens used in the request (prompt + completion)."""
+
+    # ADDED: gpt4v preview用(Noneを許容するため)
+    @field_validator("completion_tokens", "prompt_tokens", "total_tokens", mode="before")
+    def validate_name(cls, v: int | None) -> int:
+        return v or 0
+
+
+class CompletionUsageForCustomPriceCalculation(DictableBaseModel):
+    completion_tokens: int
+    """Number of tokens in the generated completion."""
+
+    prompt_tokens: int
+    """Number of tokens in the prompt."""
+
+    total_tokens: int
+    """Total number of tokens used in the request (prompt + completion)."""
+
+    # ADDED: gpt4v preview用(Noneを許容するため)
+    @field_validator("completion_tokens", "prompt_tokens", "total_tokens", mode="before")
+    def validate_name(cls, v: int | None) -> int:
+        return v or 0
+
+
+class Function(DictableBaseModel):
+    arguments: str
+    """
+    The arguments to call the function with, as generated by the model in JSON
+    format. Note that the model does not always generate valid JSON, and may
+    hallucinate parameters not defined by your function schema. Validate the
+    arguments in your code before calling your function.
+    """
+
+    name: str
+    """The name of the function to call."""
+
+
+class ChatCompletionMessageToolCall(DictableBaseModel):
+    id: str
+    """The ID of the tool call."""
+
+    function: Function
+    """The function that the model called."""
+
+    type: Literal["function"]
+    """The type of the tool. Currently, only `function` is supported."""
+
+
+class FunctionCall(DictableBaseModel):
+    arguments: str
+    """
+    The arguments to call the function with, as generated by the model in JSON
+    format. Note that the model does not always generate valid JSON, and may
+    hallucinate parameters not defined by your function schema. Validate the
+    arguments in your code before calling your function.
+    """
+
+    name: str
+    """The name of the function to call."""
+
+
+class ChatCompletionMessage(DictableBaseModel):
+    content: Optional[str]
+    """The contents of the message."""
+
+    role: Literal["assistant"]
+    """The role of the author of this message."""
+
+    function_call: Optional[FunctionCall] = None
+    """Deprecated and replaced by `tool_calls`.
+
+    The name and arguments of a function that should be called, as generated by the
+    model.
+    """
+
+    tool_calls: Optional[List[ChatCompletionMessageToolCall]] = None
+    """The tool calls generated by the model, such as function calls."""
+
+    def to_typeddict_message(self) -> ChatCompletionAssistantMessageParam:
+        message_dict = ChatCompletionAssistantMessageParam(role=self.role, content=self.content)
+        if self.function_call is not None:
+            message_dict["function_call"] = FunctionCallParams(
+                arguments=self.function_call.arguments, name=self.function_call.name
+            )
+        if self.tool_calls is not None:
+            message_dict["tool_calls"] = [
+                ChatCompletionMessageToolCallParam(
+                    id=tool_call.id,
+                    function=FunctionParams(arguments=tool_call.function.arguments, name=tool_call.function.name),
+                    type=tool_call.type,
+                )
+                for tool_call in self.tool_calls
+            ]
+        return message_dict
+
+
+FinishReason = Literal["stop", "length", "tool_calls", "content_filter", "function_call"]
+
+
+class Choice(DictableBaseModel):
+    finish_reason: FinishReason | None = None  # ADDED: gpt4v preview用
+    """The reason the model stopped generating tokens.
+
+    This will be `stop` if the model hit a natural stop point or a provided stop
+    sequence, `length` if the maximum number of tokens specified in the request was
+    reached, `content_filter` if content was omitted due to a flag from our content
+    filters, `tool_calls` if the model called a tool, or `function_call`
+    (deprecated) if the model called a function.
+    """
+
+    index: int
+    """The index of the choice in the list of choices."""
+
+    message: ChatCompletionMessage
+    """A chat completion message generated by the model."""
+
+
+class ChatCompletion(DictableBaseModel):
+    id: str
+    """A unique identifier for the chat completion."""
+
+    choices: List[Choice]
+    """A list of chat completion choices.
+
+    Can be more than one if `n` is greater than 1.
+    """
+
+    created: int
+    """The Unix timestamp (in seconds) of when the chat completion was created."""
+
+    model: str
+    """The model used for the chat completion."""
+
+    object: Literal["chat.completion"] | str
+    """The object type, which is always `chat.completion`."""
+
+    system_fingerprint: Optional[str] = None
+    """This fingerprint represents the backend configuration that the model runs with.
+
+    Can be used in conjunction with the `seed` request parameter to understand when
+    backend changes have been made that might impact determinism.
+    """
+
+    usage: Optional[CompletionUsage] = None
+    """Usage statistics for the completion request."""

neollm/types/openai/chat_completion_chunk.py

@@ -0,0 +1,109 @@
+from typing import List, Literal, Optional
+
+from pydantic import field_validator
+
+from neollm.types._model import DictableBaseModel
+from neollm.utils.utils import cprint
+
+
+class ChoiceDeltaFunctionCall(DictableBaseModel):
+    arguments: Optional[str] = None
+    """
+    The arguments to call the function with, as generated by the model in JSON
+    format. Note that the model does not always generate valid JSON, and may
+    hallucinate parameters not defined by your function schema. Validate the
+    arguments in your code before calling your function.
+    """
+
+    name: Optional[str] = None
+    """The name of the function to call."""
+
+
+class ChoiceDeltaToolCallFunction(DictableBaseModel):
+    arguments: Optional[str] = None
+    """
+    The arguments to call the function with, as generated by the model in JSON
+    format. Note that the model does not always generate valid JSON, and may
+    hallucinate parameters not defined by your function schema. Validate the
+    arguments in your code before calling your function.
+    """
+
+    name: Optional[str] = None
+    """The name of the function to call."""
+
+
+class ChoiceDeltaToolCall(DictableBaseModel):
+    index: int
+
+    id: Optional[str] = None
+    """The ID of the tool call."""
+
+    function: Optional[ChoiceDeltaToolCallFunction] = None
+
+    type: Optional[Literal["function"]] = None
+    """The type of the tool. Currently, only `function` is supported."""
+
+
+class ChoiceDelta(DictableBaseModel):
+    content: Optional[str] = None
+    """The contents of the chunk message."""
+
+    function_call: Optional[ChoiceDeltaFunctionCall] = None
+    """Deprecated and replaced by `tool_calls`.
+
+    The name and arguments of a function that should be called, as generated by the
+    model.
+    """
+
+    role: Optional[Literal["system", "user", "assistant", "tool"]] = None
+    """The role of the author of this message."""
+
+    tool_calls: Optional[List[ChoiceDeltaToolCall]] = None
+
+
+class ChunkChoice(DictableBaseModel):  # chat_completionと同名なため、改名(Choice->ChunkChoice)
+    delta: ChoiceDelta
+    """A chat completion delta generated by streamed model responses."""
+
+    finish_reason: Optional[Literal["stop", "length", "tool_calls", "content_filter", "function_call"]]
+    """The reason the model stopped generating tokens.
+
+    This will be `stop` if the model hit a natural stop point or a provided stop
+    sequence, `length` if the maximum number of tokens specified in the request was
+    reached, `content_filter` if content was omitted due to a flag from our content
+    filters, `tool_calls` if the model called a tool, or `function_call`
+    (deprecated) if the model called a function.
+    """
+
+    index: int
+    """The index of the choice in the list of choices."""
+
+
+class ChatCompletionChunk(DictableBaseModel):
+    id: str
+    """A unique identifier for the chat completion. Each chunk has the same ID."""
+
+    choices: List[ChunkChoice]
+    """A list of chat completion choices.
+
+    Can be more than one if `n` is greater than 1.
+    """
+
+    created: int
+    """The Unix timestamp (in seconds) of when the chat completion was created.
+
+    Each chunk has the same timestamp.
+    """
+
+    model: str
+    """The model to generate the completion."""
+
+    object: Literal["chat.completion.chunk"] = "chat.completion.chunk"  # for azure
+    """The object type, which is always `chat.completion.chunk`."""
+
+    # ADDED: azure用 (""を許容するため)
+    @field_validator("object", mode="before")
+    def validate_name(cls, v: str) -> Literal["chat.completion.chunk"]:
+        if v != "" and v != "chat.completion.chunk":
+            cprint(f"ChatCompletionChunk.object is not 'chat.completion.chunk': {v}", "yellow")
+        return "chat.completion.chunk"

neollm/utils/inference.py

@@ -0,0 +1,70 @@
+import csv
+import glob
+import json
+from concurrent.futures import Future, ThreadPoolExecutor
+from typing import Any, Callable, TypeVar
+
+_T = TypeVar("_T")
+
+
+def execute_parallel(func: Callable[..., _T], kwargs_list: list[dict[str, Any]], max_workers: int) -> list[_T]:
+    """並行処理を行う
+
+    Args:
+        func (Callable): 並行処理したい関数
+        kwargs_list (list[dict[str, Any]]): 関数の引数(dict型)のリスト
+        max_workers (int): 並行処理数
+
+    Returns:
+        list[Any]: 関数の戻り値のリスト
+    """
+    response_list: list[Future[_T]] = []
+    with ThreadPoolExecutor(max_workers=max_workers) as e:
+        for kwargs in kwargs_list:
+            response: Future[_T] = e.submit(func, **kwargs)
+            response_list.append(response)
+    return [r.result() for r in response_list]
+
+
+def _load_json_file(file_path: str) -> Any:
+    # TODO: Docstring追加
+    with open(file_path, "r", encoding="utf-8") as json_file:
+        data = json.load(json_file)
+    return data
+
+
+def make_log_csv(log_dir: str, csv_file_name: str = "log.csv") -> None:
+    """ログデータのcsvを保存
+
+    Args:
+        log_dir (str): ログデータが保存されているディレクトリ
+        csv_file_name (str, optional): 保存するcsvファイル名. Defaults to "log.csv".
+    """
+    # ディレクトリ内のJSONファイルのリストを取得
+    # TODO: エラーキャッチ
+    json_files = sorted([f for f in glob.glob(f"{log_dir}/*.json")], key=lambda x: int(x.split("/")[-1].split(".")[0]))
+
+    # すべてのJSONファイルからユニークなキーを取得
+    columns = []
+    data_list: list[dict[Any, Any]] = []
+    keys_set = set()
+    for json_file in json_files:
+        data = _load_json_file(json_file)
+        if isinstance(data, dict):
+            for key in data.keys():
+                if key not in keys_set:
+                    keys_set.add(key)
+                    columns.append(key)
+            data_list.append(data)
+
+    # CSVファイルを作成し、ヘッダーを書き込む
+    with open(csv_file_name, "w", encoding="utf-8", newline="") as csv_file:
+        writer = csv.writer(csv_file)
+        writer.writerow(columns)
+
+        # JSONファイルからデータを読み取り、CSVファイルに書き込む
+        for data in data_list:
+            row = [data.get(key, "") for key in columns]
+            writer.writerow(row)
+
+    print(f"saved csv file: {csv_file_name}")

neollm/utils/postprocess.py

@@ -0,0 +1,120 @@
+import json
+from typing import Any, overload
+
+
+# string ---------------------------------------
+def _extract_string(text: str, start_string: str | None = None, end_string: str | None = None) -> str:
+    """
+    テキストから必要な文字列を抽出する
+
+    Args:
+        text (str): 抽出するテキスト
+
+    Returns:
+        str: 抽出された必要な文字列
+    """
+    # 最初の文字
+    if start_string is not None and start_string in text:
+        idx_head = text.index(start_string)
+        text = text[idx_head:]
+    # 最後の文字
+    if end_string is not None and end_string in text:
+        idx_tail = len(text) - text[::-1].index(end_string[::-1])
+        text = text[:idx_tail]
+    return text
+
+
+def _delete_first_chapter_tag(text: str, first_character_tag: str | list[str]) -> str:
+    """_summary_
+
+    Args:
+        text (str): テキスト
+        first_character_tag (str | list[str]): 最初にある余分な文字列
+
+    Returns:
+        str: 除去済みのテキスト
+    """
+    # first_character_tagのlist化
+    if isinstance(first_character_tag, str):
+        first_character_tag = [first_character_tag]
+    # 最初のチャプタータグの消去
+    for first_character_i in first_character_tag:
+        if text.startswith(first_character_i):
+            text = text[len(first_character_i) :]
+            break
+    return text.strip()
+
+
+def strip_string(
+    text: str,
+    first_character: str | list[str] = ["<output>", "<outputs>"],
+    start_string: str | None = None,
+    end_string: str | None = None,
+    strip_quotes: str | list[str] = ["'", '"'],
+) -> str:
+    """stringの前後の余分な文字を削除する
+
+    Args:
+        text (str): ChatGPTの出力文字列
+        first_character (str, optional): 出力の先頭につく文字 Defaults to ["<output>", "<outputs>"].
+        start_string (str, optional): 出力の先頭につく文字 Defaults to None.
+        end_string (str, optional): 出力の先頭につく文字 Defaults to None.
+        strip_quotes (str, optional): 前後の余分な'"を消す. Defaults to ["'", '"'].
+
+    Returns:
+        str: 余分な文字列を消去した文字列
+
+    Examples:
+        >>> strip_string("<output>'''ChatGPT is smart!'''", "<output>")
+        ChatGPT is smart!
+        >>> strip_string('{"a": 1}', start_string="{", end_string="}")
+        {"a": 1}
+        >>> strip_string("<outputs>  `neoAI`", strip_quotes="`")
+        neoAI
+    """
+    # 余分な文字列消去
+    text = _delete_first_chapter_tag(text, first_character)
+    # 前後の'" を消す
+    if isinstance(strip_quotes, str):
+        strip_quotes = [strip_quotes]
+    for quote in strip_quotes:
+        text = text.strip(quote).strip()
+    text = _extract_string(text, start_string, end_string)
+    return text.strip()
+
+
+# dict ---------------------------------------
+
+
+@overload
+def json2dict(json_string: str, error_key: None) -> dict[Any, Any] | str: ...
+
+
+@overload
+def json2dict(json_string: str, error_key: str) -> dict[Any, Any]: ...
+
+
+def json2dict(json_string: str, error_key: str | None = "error") -> dict[Any, Any] | str:
+    """
+    JSON文字列をPython dictに変換する
+
+    Args:
+        json_string (str): 変換するJSON文字列
+        error_key (str, optional): エラーキーの値として代入する文字列. Defaults to "error".
+
+    Returns:
+        dict: 変換されたPython dict
+    """
+    try:
+        python_dict = json.loads(_extract_string(json_string, start_string="{", end_string="}"), strict=False)
+    except ValueError:
+        if error_key is None:
+            return json_string
+        python_dict = {error_key: json_string}
+    if isinstance(python_dict, dict):
+        return python_dict
+    return {error_key: python_dict}
+
+
+# calender
+# YYYY年MM月YY日 -> YYYY-MM-DD

neollm/utils/preprocess.py

@@ -0,0 +1,107 @@
+import json
+import re
+from typing import Any, Callable
+
+
+# dict2json --------------------------------
+def dict2json(python_dict: dict[str, Any]) -> str:
+    """
+    Python dictをJSON文字列に変換する
+
+    Args:
+        python_dict (dict): 変換するPython dict
+
+    Returns:
+        str: 変換されたJSON文字列
+    """
+    # ensure_ascii: 日本語とかを出力するため
+    json_string = json.dumps(python_dict, indent=2, ensure_ascii=False)
+    return json_string
+
+
+# optimize token --------------------------------
+def optimize_token(text: str, funcs: list[Callable[[str], str]] | None = None) -> str:
+    """
+    テキストのトークンを最適化をする
+
+    Args:
+        text (str): 最適化するテキスト
+
+    Returns:
+        str: 最適化されたテキスト
+    """
+    funcs = funcs or [minimize_newline, zenkaku_to_hankaku, remove_trailing_spaces]
+    for func in funcs:
+        text = func(text)
+    return text.strip()
+
+
+def _replace_consecutive(text: str, pattern: str, replacing_text: str) -> str:
+    """
+    テキスト内の連続するパターンに対して、指定された置換テキストで置換する
+
+    Args:
+        text (str): テキスト
+        pattern (str): 置換するパターン
+        replacing_text (str): 置換テキスト
+
+    Returns:
+        str: 置換されたテキスト
+    """
+    p = re.compile(pattern)
+    matches = [(m.start(), m.end()) for m in p.finditer(text)][::-1]
+
+    text_replaced = list(text)
+
+    for i_start, i_end in matches:
+        text_replaced[i_start:i_end] = [replacing_text]
+    return "".join(text_replaced)
+
+
+def minimize_newline(text: str) -> str:
+    """
+    テキスト内の連続する改行を2以下にする
+
+    Args:
+        text (str): テキスト
+
+    Returns:
+        str: 改行を最小限にしたテキスト
+    """
+    return _replace_consecutive(text, pattern="\n{2,}", replacing_text="\n\n")
+
+
+def zenkaku_to_hankaku(text: str) -> str:
+    """
+    テキスト内の全角文字を半角文字に変換する
+
+    Args:
+        text (str): テキスト
+
+    Returns:
+        str: 半角文字に変換されたテキスト
+    """
+    mapping_dict = {"　": " ", "：": ": ", "‎": " ", "．": "。", "，": "、", "￥": "¥"}
+    hankaku_text = ""
+    for char in text:
+        # A-Za-z0-9!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~
+        if char in mapping_dict:
+            hankaku_text += mapping_dict[char]
+        elif 65281 <= ord(char) <= 65374:
+            hankaku_text += chr(ord(char) - 65248)
+        else:
+            hankaku_text += char
+    return hankaku_text
+
+
+def remove_trailing_spaces(text: str) -> str:
+    """
+    テキスト内の各行の末尾のスペースを削除する
+
+    Args:
+        text (str): テキスト
+
+    Returns:
+        str: スペースを削除したテキスト
+    """
+    return "\n".join([line.rstrip() for line in text.split("\n")])

neollm/utils/prompt_checker.py

@@ -0,0 +1,110 @@
+from __future__ import annotations
+
+from typing import Any
+
+from typing_extensions import TypedDict
+
+from neollm import MyL3M2, MyLLM
+from neollm.types import LLMSettings, Messages, Response
+
+_MyLLM = MyLLM[Any, Any]
+_MyL3M2 = MyL3M2[Any, Any]
+
+
+class PromptCheckerInput(TypedDict):
+    myllm: _MyLLM | _MyL3M2
+    model: str
+    platform: str
+    llm_settings: LLMSettings | None
+
+
+class APromptCheckerInput(TypedDict):
+    myllm: _MyLLM
+
+
+class APromptChecker(MyLLM[APromptCheckerInput, str]):
+    def _preprocess(self, inputs: APromptCheckerInput) -> Messages:
+        system_prompt = (
+            "あなたは、AIへの指示(プロンプト)をより良くすることが仕事です。\n"
+            "あなたは言語能力が非常に高く、仕事も丁寧なので小さなミスも気づくことができる天才です。"
+            "誤字脱字・論理的でない点・指示が不明確な点を箇条書きで指摘し、より良いプロンプトを提案してください。\n"
+            "# 出力例: \n"
+            "[指示の誤字脱字/文法ミス]\n"
+            "- ...\n"
+            "- ...\n"
+            "[指示が論理的でない点]\n"
+            "- ...\n"
+            "- ...\n"
+            "[指示が不明確な点]\n"
+            "- ...\n"
+            "- ...\n"
+            "[その他気になる点]\n"
+            "- ...\n"
+            "- ...\n"
+            "[提案]\n"
+            "- ...\n"
+            "- ...\n"
+        )
+        if inputs["myllm"].messages is None:
+            return []
+        user_prompt = "# プロンプト\n" + "\n".join(
+            # [f"<{message['role']}>\n{message['content']}\n" for message in inputs.messages]
+            [str(message) for message in inputs["myllm"].messages]
+        )
+        messages: Messages = [
+            {"role": "system", "content": system_prompt},
+            {"role": "user", "content": user_prompt},
+        ]
+        return messages
+
+    def _postprocess(self, response: Response) -> str:
+        if response.choices[0].message.content is None:
+            return "contentがないンゴ"
+        return response.choices[0].message.content
+
+    def _ruleprocess(self, inputs: APromptCheckerInput) -> str | None:
+        if inputs["myllm"].messages is None:
+            return "ruleprocessが走って、リクエストしてないよ！"
+        return None
+
+    def __call__(self, inputs: APromptCheckerInput) -> str:
+        outputs: str = super().__call__(inputs)
+        return outputs
+
+
+class PromptsChecker(MyL3M2[PromptCheckerInput, None]):
+    def _link(self, inputs: PromptCheckerInput) -> None:
+        if isinstance(inputs["myllm"], MyL3M2):
+            for myllm in inputs["myllm"].myllm_list:
+                prompts_checker = PromptsChecker(parent=self, verbose=True)
+                prompts_checker(
+                    inputs={
+                        "myllm": myllm,
+                        "model": inputs["model"],
+                        "platform": inputs["platform"],
+                        "llm_settings": inputs["llm_settings"],
+                    }
+                )
+        elif isinstance(inputs["myllm"], MyLLM):
+            a_prompt_checker = APromptChecker(
+                parent=self,
+                llm_settings=inputs["llm_settings"],
+                verbose=True,
+                platform=inputs["platform"],
+                model=inputs["model"],
+            )
+            a_prompt_checker(inputs={"myllm": inputs["myllm"]})
+
+    def __call__(self, inputs: PromptCheckerInput) -> None:
+        super().__call__(inputs)
+
+
+def check_prompt(
+    myllm: _MyLLM | _MyL3M2,
+    llm_settings: LLMSettings | None = None,
+    model: str = "gpt-3.5-turbo",
+    platform: str = "openai",
+) -> MyL3M2[Any, Any]:
+    prompt_checker_2 = PromptsChecker(verbose=True)
+    prompt_checker_2(inputs={"myllm": myllm, "llm_settings": llm_settings, "model": model, "platform": platform})
+    return prompt_checker_2

neollm/utils/tokens.py

@@ -0,0 +1,229 @@
+import json
+import textwrap
+from typing import Any
+
+import tiktoken
+
+from neollm.types import Function  # , Functions, Messages
+
+
+def normalize_model_name(model_name: str) -> str:
+    """model_nameのトークン数計測のための標準化
+
+    Args:
+        model_name (str): model_name
+            OpenAI: gpt-3.5-turbo-0613, gpt-3.5-turbo-16k-0613, gpt-4-0613, gpt-4-32k-0613
+            OpenAIFT: ft:gpt-3.5-turbo:org_id
+            Azure: gpt-35-turbo-0613, gpt-35-turbo-16k-0613, gpt-4-0613, gpt-4-32k-0613
+
+    Returns:
+        str: 標準化されたmodel_name
+
+    Raises:
+        ValueError: model_nameが不適切
+    """
+    # 参考: https://platform.openai.com/docs/models/gpt-3-5
+    NEWEST_MAP = [
+        ("gpt-3.5-turbo-16k", "gpt-3.5-turbo-16k-0613"),
+        ("gpt-3.5-turbo", "gpt-3.5-turbo-0613"),
+        ("gpt-4-32k", "gpt-4-32k-0613"),
+        ("gpt-4", "gpt-4-0613"),
+    ]
+    ALL_VERSION_MODELS = [
+        # gpt-3.5-turbo
+        "gpt-3.5-turbo-0613",
+        "gpt-3.5-turbo-16k-0613",
+        "gpt-3.5-turbo-0301",  # Legacy
+        # gpt-4
+        "gpt-4-0613",
+        "gpt-4-32k-0613",
+        "gpt-4-0314",  # Legacy
+        "gpt-4-32k-0314",  # Legacy
+    ]
+    # Azure表記 → OpenAI表記に統一
+    model_name = model_name.replace("gpt-35", "gpt-3.5")
+    # 最新モデルを正式名称に & 新モデル, FTモデルをキャッチ
+    if model_name not in ALL_VERSION_MODELS:
+        for key, model_name_version in NEWEST_MAP:
+            if key in model_name:
+                model_name = model_name_version
+                break
+    # Return
+    if model_name in ALL_VERSION_MODELS:
+        return model_name
+    raise ValueError("model_name は以下から選んで．\n" + ",".join(ALL_VERSION_MODELS))
+
+
+def count_tokens(messages: Any | None = None, model_name: str | None = None, functions: Any | None = None) -> int:
+    """トークン数計測
+
+    Args:
+        messages (Messages): GPTAPIの入力のmessages
+        model_name (str | None, optional): モデル名. Defaults to None.
+        functions (Functions | None, optional): GPTAPIの入力のfunctions. Defaults to None.
+
+    Returns:
+        int: トークン数
+    """
+    model_name = normalize_model_name(model_name or "cl100k_base")
+    num_tokens = _count_messages_tokens(messages, model_name)
+    if functions is not None:
+        num_tokens += _count_functions_tokens(functions, model_name)
+    return num_tokens
+
+
+# https://github.com/openai/openai-cookbook/blob/main/examples/How_to_count_tokens_with_tiktoken.ipynb
+def _count_messages_tokens(messages: Any | None, model_name: str) -> int:
+    """メッセージのトークン数を計算
+
+    Args:
+        messages (Messages): ChatGPT等APIに入力するmessages
+        model_name (str, optional): 使用するモデルの名前
+            "gpt-3.5-turbo-0613", "gpt-3.5-turbo-16k-0613", "gpt-4-0314", "gpt-4-32k-0314"
+            "gpt-4-0613", "gpt-4-32k-0613", "gpt-3.5-turbo", "gpt-4"
+
+    Returns:
+        int: トークン数の合計
+    """
+    if messages is None:
+        return 0
+    # setting model
+    encoding_model = tiktoken.encoding_for_model(model_name)  # "cl100k_base"
+
+    # config
+    if model_name == "gpt-3.5-turbo-0301":
+        tokens_per_message = 4  # every message follows <|start|>{role/name}\n{content}<|end|>\n
+        tokens_per_name = -1  # if there's a name, the role is omitted
+    else:
+        tokens_per_message = 3
+        tokens_per_name = 1
+
+    # count tokens
+    num_tokens = 3  # every reply is primed with <|start|>assistant<|message|>
+    for message in messages:
+        num_tokens += tokens_per_message
+        for key, value in message.items():
+            if isinstance(value, str):
+                num_tokens += len(encoding_model.encode(value))
+            if key == "name":
+                num_tokens += tokens_per_name
+    return num_tokens
+
+
+# https://gist.github.com/CGamesPlay/dd4f108f27e2eec145eedf5c717318f5
+def _count_functions_tokens(functions: Any, model_name: str | None = None) -> int:
+    """
+    functionsのトークン数計測
+
+    Args:
+        functions (Functions): GPTAPIの入力のfunctions
+        model_name (str | None, optional): モデル名. Defaults to None.
+
+    Returns:
+        _type_: トークン数
+    """
+    encoding_model = tiktoken.encoding_for_model(model_name or "cl100k_base")  # "cl100k_base"
+    num_tokens = 3 + len(encoding_model.encode(__functions2string(functions)))
+    return num_tokens
+
+
+# functionsのstring化、補助関数 ---------------------------------------------------------------------------
+def __functions2string(functions: Any) -> str:
+    """functionsの文字列化
+
+    Args:
+        functions (Functions): GPTAPIの入力のfunctions
+
+    Returns:
+        str: functionsの文字列
+    """
+    prefix = "# Tools\n\n## functions\n\nnamespace functions {\n\n} // namespace functions\n"
+    functions_string = prefix + "".join(__function2string(function) for function in functions)
+    return functions_string
+
+
+def __function2string(function: Function) -> str:
+    """functionの文字列化
+
+    Args:
+        function (Function): GPTAPIのfunctionの要素
+
+    Returns:
+        str: functionの文字列
+    """
+    object_string = __format_object(function["parameters"])
+    if object_string is not None:
+        object_string = "_: " + object_string
+    else:
+        object_string = ""
+
+    functions_string: str = (
+        f"// {function['description']}\ntype {function['name']} = (" + object_string + ") => any;\n\n"
+    )
+    return functions_string
+
+
+def __format_object(schema: dict[str, Any], indent: int = 0) -> str | None:
+    if "properties" not in schema or len(schema["properties"]) == 0:
+        if schema.get("additionalProperties", False):
+            return "object"
+        return None
+
+    result = "{\n"
+    for key, value in dict(schema["properties"]).items():
+        # value <- resolve_ref(value)
+        value_rendered = __format_schema(value, indent + 1)
+        if value_rendered is None:
+            continue
+        # description
+        if "description" in value:
+            description = "".join(
+                "  " * indent + f"// {description_i}\n"
+                for description_i in textwrap.dedent(value["description"]).strip().split("\n")
+            )
+        # optional
+        optional = "" if key in schema.get("required", {}) else "?"
+        # default
+        default_comment = "" if "default" not in value else f" // default: {__format_default(value)}"
+        # add string
+        result += description + "  " * indent + f"{key}{optional}: {value_rendered},{default_comment}\n"
+    result += ("  " * (indent - 1)) + "}"
+    return result
+
+
+# よくわからん
+# def resolve_ref(schema):
+#     if schema.get("$ref") is not None:
+#         ref = schema["$ref"][14:]
+#         schema = json_schema["definitions"][ref]
+#     return schema
+
+
+def __format_schema(schema: dict[str, Any], indent: int) -> str | None:
+    # schema <- resolve_ref(schema)
+    if "enum" in schema:
+        return __format_enum(schema)
+    elif schema["type"] == "object":
+        return __format_object(schema, indent)
+    elif schema["type"] in {"integer", "number"}:
+        return "number"
+    elif schema["type"] in {"string"}:
+        return "string"
+    elif schema["type"] == "array":
+        return str(__format_schema(schema["items"], indent)) + "[]"
+    else:
+        raise ValueError("unknown schema type " + schema["type"])
+
+
+def __format_enum(schema: dict[str, Any]) -> str:
+    # "A" | "B" | "C"
+    return " | ".join(json.dumps(element, ensure_ascii=False) for element in schema["enum"])
+
+
+def __format_default(schema: dict[str, Any]) -> str:
+    default = schema["default"]
+    if schema["type"] == "number" and float(default).is_integer():
+        # numberの時、0 → 0.0
+        return f"{default:.1f}"
+    else:
+        return str(default)

neollm/utils/utils.py

@@ -0,0 +1,98 @@
+from __future__ import annotations
+
+import os
+from typing import Any
+
+from typing_extensions import TypedDict
+
+from neollm.types import PrintColor
+
+
+class CPrintParam(TypedDict, total=False):
+    text: Any
+    color: PrintColor | None
+    background: bool
+    light: bool
+    bold: bool
+    italic: bool
+    underline: bool
+    kwargs: dict[str, Any]
+
+
+def cprint(
+    *text: Any,
+    color: PrintColor | None = None,
+    background: bool = False,
+    light: bool = False,
+    bold: bool = False,
+    italic: bool = False,
+    underline: bool = False,
+    kwargs: dict[str, Any] = {},
+) -> None:
+    """
+    色付けなどリッチにprint
+
+    Args:
+        *text: 表示するテキスト。
+        color (PrintColor): テキストの色: 'black', 'red', 'green', 'yellow', 'blue', 'magenta', 'cyan', 'white'。
+        background (bool): 背景色
+        light (bool): 淡い色にするか
+        bold (bool): 太字
+        italic (bool): 斜体
+        underline (bool): 下線
+        **kwargs: printの引数
+    """
+    # ANSIエスケープシーケンスを使用して、テキストを書式設定して表示する
+    format_string = ""
+
+    # 色の設定
+    color2code: dict[PrintColor, int] = {
+        "black": 30,
+        "red": 31,
+        "green": 32,
+        "yellow": 33,
+        "blue": 34,
+        "magenta": 35,
+        "cyan": 36,
+        "white": 37,
+    }
+    if color is not None and color in color2code:
+        code = color2code[color]
+        if background:
+            code += 10
+        elif light:
+            code += 60
+        format_string += f"\033[{code}m"
+    if bold:
+        format_string += "\033[1m"
+    if italic:
+        format_string += "\033[3m"
+    if underline:
+        format_string += "\033[4m"
+
+    # テキストの表示
+    for text_i in text:
+        print(format_string + str(text_i) + "\033[0m", **kwargs)
+
+
+def ensure_env_var(var_name: str | None = None, default: str | None = None) -> str:
+    if var_name is None:
+        return ""
+    if os.environ.get(var_name, "") == "":
+        if default is None:
+            raise ValueError(f"{var_name}をenvで設定しよう")
+        cprint(f"WARNING: {var_name}が設定されていません。{default}を使用します。", color="yellow", background=True)
+        os.environ[var_name] = default
+    return os.environ[var_name]
+
+
+def suport_unrecomended_env_var(old_key: str, new_key: str) -> None:
+    """非推奨の環境変数をサポートする
+
+    Args:
+        old_key (str): 非推奨の環境変数名
+        new_key (str): 推奨の環境変数名
+    """
+    if os.getenv(old_key) is not None and os.getenv(new_key) is None:
+        cprint(f"WARNING: {old_key}ではなく、{new_key}にしてね", color="yellow", background=True)
+        os.environ[new_key] = os.environ[old_key]

project/.env.template

@@ -0,0 +1,24 @@
+LLM_PLATFORM=azure
+
+# OpenAIkey
+OPENAI_API_KEY=sk-XXX
+
+# Azure OpenAIkey
+AZURE_OPENAI_API_KEY=XXX  # AZURE_OPENAI_AD_TOKEN=YYY
+AZURE_OPENAI_ENDPOINT=https://neoai-pjname.openai.azure.com/    # (not-recomended): AZURE_API_BASE
+OPENAI_API_VERSION=2024-02-01   # (not-recomended): AZURE_API_VERSION
+
+# ENGINE
+# 1106 ----------------------------------------------------------
+AZURE_ENGINE_GPT35T_1106=xxx
+AZURE_ENGINE_GPT4T_1106=xxx
+# 0613 ----------------------------------------------------------
+AZURE_ENGINE_GPT35T_0613=neoai-pjname-gpt-35  # (not-recomended): AZURE_ENGINE_GPT35, AZURE_ENGINE_GPT35_0613
+AZURE_ENGINE_GPT35T_16K_0613=neoai-pjname-gpt-35-16k  # (not-recomended): AZURE_ENGINE_GPT35_16k, AZURE_ENGINE_GPT35_16K_0613
+AZURE_ENGINE_GPT4_0613=neoai-pjname-gpt4  # (not-recomended): AZURE_ENGINE_GPT4
+AZURE_ENGINE_GPT4_32K_0613=neoai-pjname-gpt4-32k  # (not recomended): AZURE_ENGINE_GPT4_32k
+
+# Anthropic
+ANTHROPIC_API_KEY=xxx
+
+# GCP

project/ex_module/ex_profile_extractor.py

@@ -0,0 +1,113 @@
+from typing import Any, Literal, TypedDict
+
+from neollm import MyLLM
+from neollm.types import Functions
+from neollm.utils.postprocess import json2dict
+from neollm.utils.preprocess import optimize_token
+
+
+class ProfileExtractorInputType(TypedDict):
+    text: str
+
+
+class ProfileExtractorOuputType(TypedDict):
+    name: str
+    birth_year: int
+    domain: str
+    lang: Literal["ENG", "JPN"]
+
+
+class ProfileExtractor(MyLLM):
+    """情報を抽出するMyLLM
+
+    Notes:
+        inputs:
+            >>> {"text": str}
+        outpus:
+            >>> {"text_translated": str | None(うまくいかなかった場合)}
+    """
+
+    def _preprocess(self, inputs: ProfileExtractorInputType):
+        system_prompt = "<input>より情報を抽出する。存在しない場合nullとする"
+        user_prompt = "<input>\n" f"'''{inputs['text'].strip()}'''"
+        messages = [
+            {"role": "system", "content": optimize_token(system_prompt)},
+            {"role": "user", "content": optimize_token(user_prompt)},
+        ]
+        return messages
+
+    def _check_input(
+        self, inputs: ProfileExtractorInputType, messages
+    ) -> tuple[bool, ProfileExtractorOuputType | None]:
+        # 入力がない場合の処理
+        if inputs["text"].strip() == "":
+            # requestしない, ルールベースのoutput
+            return False, {"name": "", "birth_year": -1, "domain": "", "lang": "JPN"}
+        # 入力が多い時に16kを使う
+        if self.llm.count_tokens(messages) >= 1600:
+            self.model = "gpt-3.5-turbo-16k"
+        else:
+            self.model = "gpt-3.5-turbo"
+        # requestする, _
+        return True, None
+
+    def _postprocess(self, response) -> ProfileExtractorOuputType:
+        if dict(response["choices"][0]["message"]).get("function_call"):
+            try:
+                extracted_data = json2dict(response["choices"][0]["message"]["function_call"]["arguments"])
+            except Exception:
+                extracted_data = {}
+        else:
+            extracted_data = {}
+
+        lang_ = extracted_data.get("lang")
+        if lang_ in {"ENG", "JPN"}:
+            lang = lang_
+        else:
+            lang = "JPN"
+
+        outputs: ProfileExtractorOuputType = {
+            "name": str(extracted_data.get("name") or ""),
+            "birth_year": int(extracted_data.get("birth_year") or -1),
+            "domain": str(extracted_data.get("domain") or ""),
+            "lang": lang,
+        }
+        return outputs
+
+    # Function Callingを使う場合必要
+    def _add_functions(self, inputs: Any) -> Functions | None:
+        functions: Functions = [
+            {
+                "name": "extract_profile",
+                "description": "extract profile of a person",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "name": {
+                            "type": "string",
+                            "description": "名前",
+                        },
+                        "domain": {
+                            "type": "string",
+                            "description": "研究ドメイン カンマ区切り",
+                        },
+                        "birth_year": {
+                            "type": "integer",
+                            "description": "the year of the birth YYYY",
+                        },
+                        "lang": {
+                            "type": "string",
+                            "description": "the language of the text",
+                            "enum": ["ENG", "JPN"],
+                        },
+                    },
+                    "required": ["name", "birth_year", "domain", "lang"],
+                },
+            }
+        ]
+        return functions
+
+    # 型定義のために必要
+    def __call__(self, inputs: ProfileExtractorInputType) -> ProfileExtractorOuputType:
+        outputs: ProfileExtractorOuputType = super().__call__(inputs)
+        return outputs

project/ex_module/ex_translated_profile_extractor.py

@@ -0,0 +1,49 @@
+from typing import TypedDict
+
+from ex_profile_extractor import ProfileExtractor, ProfileExtractorInputType
+from ex_translator import Translator
+
+from neollm import MyL3M2
+
+
+class TranslatedProfileExtractorOutputType(TypedDict):
+    name_ENG: str
+    name_JPN: str
+    domain_ENG: str
+    domain_JPN: str
+    birth_year: int
+
+
+class TranslatedProfileExtractor(MyL3M2):
+    def _link(self, inputs: ProfileExtractorInputType) -> TranslatedProfileExtractorOutputType:
+        # Profile Extract
+        profile_extractor = ProfileExtractor(parent=self, silent_list=["llm_settings", "inputs", "messages"])
+        profile = profile_extractor(inputs)
+        # Translator name
+        translator_name = Translator(parent=self, silent_list=["llm_settings", "inputs", "messages"])
+        translated_name = translator_name(inputs={"text": profile["name"]})["text_translated"]
+        # Translate domain
+        translator_domain = Translator(parent=self, silent_list=["llm_settings", "inputs", "messages"])
+        translated_domain = translator_domain(inputs={"text": profile["domain"]})["text_translated"]
+
+        outputs: TranslatedProfileExtractorOutputType = {
+            "name_ENG": profile["name"],
+            "name_JPN": profile["name"],
+            "domain_ENG": profile["domain"],
+            "domain_JPN": profile["domain"],
+            "birth_year": profile["birth_year"],
+        }
+
+        if profile["lang"] == "ENG":
+            outputs["name_JPN"] = translated_name
+            outputs["domain_JPN"] = translated_domain
+        else:
+            outputs["name_ENG"] = translated_name
+            outputs["domain_ENG"] = translated_domain
+
+        return outputs
+
+    # 型定義のために必要
+    def __call__(self, inputs: ProfileExtractorInputType) -> TranslatedProfileExtractorOutputType:
+        outputs: TranslatedProfileExtractorOutputType = super().__call__(inputs)
+        return outputs

project/ex_module/ex_translator.py

@@ -0,0 +1,62 @@
+from typing import TypedDict
+
+from neollm import MyLLM
+from neollm.types import Messages, OpenAIResponse
+from neollm.utils.postprocess import strip_string
+from neollm.utils.preprocess import optimize_token
+
+
+class TranslatorInputType(TypedDict):
+    text: str
+
+
+class TranslatorOuputType(TypedDict):
+    text_translated: str
+
+
+class Translator(MyLLM):
+    """情報を抽出するMyLLM
+
+    Notes:
+        inputs:
+            >>> {"text": str}
+        outpus:
+            >>> {"text_translated": str | None(うまくいかなかった場合)}
+    """
+
+    def _preprocess(self, inputs: TranslatorInputType) -> Messages:
+        system_prompt = (
+            "You are a good translator. Translate Japanese into English or English into Japanese.\n"
+            "# output_format:\n<output>\n{translated text in English or Japanese}"
+        )
+        user_prompt = "<input>\n" f"'''{inputs['text'].strip()}'''"
+        messages: Messages = [
+            {"role": "system", "content": optimize_token(system_prompt)},
+            {"role": "user", "content": optimize_token(user_prompt)},
+        ]
+        return messages
+
+    def _ruleprocess(self, inputs: TranslatorInputType) -> None | TranslatorOuputType:
+        # 入力がない場合の処理
+        if inputs["text"].strip() == "":
+            return {"text_translated": ""}
+        return None
+
+    def _update_settings(self) -> None:
+        # 入力が多い時に16kを使う
+        if self.messages is not None:
+            if self.llm.count_tokens(self.messages) >= 1600:
+                self.model = "gpt-3.5-turbo-16k"
+            else:
+                self.model = "gpt-3.5-turbo"
+
+    def _postprocess(self, response: OpenAIResponse) -> TranslatorOuputType:
+        text_translated: str = str(response.choices[0].message["content"])
+        text_translated = strip_string(text=text_translated, first_character=["<output>", "<outputs>"])
+        outputs: TranslatorOuputType = {"text_translated": text_translated}
+        return outputs
+
+    # 型定義のために必要
+    def __call__(self, inputs: TranslatorInputType) -> TranslatorOuputType:
+        outputs: TranslatorOuputType = super().__call__(inputs)
+        return outputs

project/neollm-tutorial.ipynb

@@ -0,0 +1,713 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# <font color=orange> settings\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 1. install neollm\n",
+    "\n",
+    "[Document インストール方法](https://www.notion.so/c760d96f1b4240e6880a32bee96bba35)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# githubのssh接続してね\n",
+    "# versionは適宜変更してね\n",
+    "%pip install git+https://github.com/neoAI-inc/neo-llm-module.git@v1.2.6\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 2 環境変数の設定方法\n",
+    "\n",
+    "[Document env ファイルの作り方](https://www.notion.so/env-32ebb04105684a77bbc730c39865df34)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "環境変数読み込み成功\n"
+     ]
+    }
+   ],
+   "source": [
+    "from dotenv import load_dotenv\n",
+    "\n",
+    "env_path = \".env\"  # .envのpath 適宜変更\n",
+    "if load_dotenv(env_path):\n",
+    "    print(\"環境変数読み込み成功\")\n",
+    "else:\n",
+    "    print(\"path違うよ〜\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# <font color=orange> neoLLM 　使い方\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "neollm は、前処理・LLM のリクエスト・後処理を 1 つのクラスにした、Pytorch 的な記法で書ける neoAI の LLM 統一ライブラリ。\n",
+    "\n",
+    "大きく 2 種類のクラスがあり、MyLLM は 1 つのリクエスト、MyL3M2 は複数のリクエストを受け持つことができる。\n",
+    "\n",
+    "![概観図](../asset/external_view.png)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "##### モデルの定義\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\u001b[43mWARNING: AZURE_API_BASEではなく、AZURE_OPENAI_ENDPOINTにしてね\u001b[0m\n",
+      "\u001b[43mWARNING: AZURE_API_VERSIONではなく、OPENAI_API_VERSIONにしてね\u001b[0m\n"
+     ]
+    }
+   ],
+   "source": [
+    "from neollm import MyLLM\n",
+    "\n",
+    "# 例: 翻訳をするclass\n",
+    "# _preprocess, _postprocessを必ず書く\n",
+    "\n",
+    "\n",
+    "class Translator(MyLLM):\n",
+    "    # _preprocessは、前処理をしてMessageを作る関数\n",
+    "    def _preprocess(self, inputs: str):\n",
+    "        messages = [\n",
+    "            {\"role\": \"system\", \"content\": \"英語を日本語に翻訳するAIです。\"},\n",
+    "            {\"role\": \"user\", \"content\": inputs},\n",
+    "        ]\n",
+    "        return messages\n",
+    "\n",
+    "    # _postprocessは、APIのResponseを後処理をして、欲しいものを返す関数\n",
+    "    def _postprocess(self, response):\n",
+    "        text_translated: str = str(response.choices[0].message.content)\n",
+    "        return text_translated"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "##### モデルの呼び出し\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\u001b[41mPARENT\u001b[0m\n",
+      "MyLLM(Translator) ----------------------------------------------------------------------------------\n",
+      "\u001b[34m[inputs]\u001b[0m\n",
+      "\"Hello, We are neoAI.\"\n",
+      "\u001b[34m[messages]\u001b[0m\n",
+      " \u001b[32msystem\u001b[0m\n",
+      "  英語を日本語に翻訳するAIです。\n",
+      " \u001b[32muser\u001b[0m\n",
+      "  Hello, We are neoAI.\n",
+      " \u001b[32massistant\u001b[0m\n",
+      "  こんにちは、私たちはneoAIです。\n",
+      "\u001b[34m[outputs]\u001b[0m\n",
+      "\"こんにちは、私たちはneoAIです。\"\n",
+      "\u001b[34m[client_settings]\u001b[0m -\n",
+      "\u001b[34m[llm_settings]\u001b[0m {'platform': 'azure', 'temperature': 1, 'model': 'gpt-3.5-turbo-0613', 'engine': 'neoai-free-swd-gpt-35-0613'}\n",
+      "\u001b[34m[metadata]\u001b[0m 1.6s; 45(36+9)tokens; $6.8e-05; ¥0.0095\n",
+      "----------------------------------------------------------------------------------------------------\n",
+      "こんにちは、私たちはneoAIです。\n"
+     ]
+    }
+   ],
+   "source": [
+    "# 初期化 (platformやmodelなど設定をしておく)\n",
+    "# 詳細: https://www.notion.so/neollm-MyLLM-581cd7562df9473b91c981d88469c452?pvs=4#ac5361a5e3fa46a48441fdd538858fee\n",
+    "translator = Translator(\n",
+    "    platform=\"azure\",  # azure or openai\n",
+    "    model=\"gpt-3.5-turbo-0613\",  # gpt-3.5-turbo-1106, gpt-4-turbo-1106\n",
+    "    llm_settings={\"temperature\": 1},  # llmの設定 dictで渡す\n",
+    ")\n",
+    "\n",
+    "# 呼び出し\n",
+    "# preprocessでinputsとしたものを入力として、postprocessで処理したものを出力とする。\n",
+    "translated_text = translator(inputs=\"Hello, We are neoAI.\")\n",
+    "print(translated_text)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "時間 1.5658628940582275\n",
+      "token数 TokenInfo(input=36, output=9, total=45)\n",
+      "token数合計 45\n",
+      "値段(USD) PriceInfo(input=5.4e-05, output=1.8e-05, total=6.75e-05)\n",
+      "値段数合計(USD) 6.75e-05\n"
+     ]
+    }
+   ],
+   "source": [
+    "# 処理時間\n",
+    "print(\"時間\", translator.time)\n",
+    "# トークン数\n",
+    "print(\"token数\", translator.token)\n",
+    "print(\"token数合計\", translator.token.total)\n",
+    "# 値段の取得\n",
+    "print(\"値段(USD)\", translator.price)\n",
+    "print(\"値段数合計(USD)\", translator.price.total)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "inputs Hello, We are neoAI.\n",
+      "messages [{'role': 'system', 'content': '英語を日本語に翻訳するAIです。'}, {'role': 'user', 'content': 'Hello, We are neoAI.'}]\n",
+      "response ChatCompletion(id='chatcmpl-8T5MkidV9bhqewdzcUwO1PioHOSHi', choices=[Choice(finish_reason='stop', index=0, message=ChatCompletionMessage(content='こんにちは、私たちはneoAIです。', role='assistant', function_call=None, tool_calls=None), content_filter_results={'hate': {'filtered': False, 'severity': 'safe'}, 'self_harm': {'filtered': False, 'severity': 'safe'}, 'sexual': {'filtered': False, 'severity': 'safe'}, 'violence': {'filtered': False, 'severity': 'safe'}})], created=1701942830, model='gpt-35-turbo', object='chat.completion', system_fingerprint=None, usage=CompletionUsage(completion_tokens=9, prompt_tokens=36, total_tokens=45), prompt_filter_results=[{'prompt_index': 0, 'content_filter_results': {'hate': {'filtered': False, 'severity': 'safe'}, 'self_harm': {'filtered': False, 'severity': 'safe'}, 'sexual': {'filtered': False, 'severity': 'safe'}, 'violence': {'filtered': False, 'severity': 'safe'}}}])\n",
+      "outputs こんにちは、私たちはneoAIです。\n",
+      "chat_history [{'role': 'system', 'content': '英語を日本語に翻訳するAIです。'}, {'role': 'user', 'content': 'Hello, We are neoAI.'}, {'content': 'こんにちは、私たちはneoAIです。', 'role': 'assistant'}]\n"
+     ]
+    }
+   ],
+   "source": [
+    "# その他property\n",
+    "print(\"inputs\", translator.inputs)\n",
+    "print(\"messages\", translator.messages)\n",
+    "print(\"response\", translator.response)\n",
+    "print(\"outputs\", translator.outputs)\n",
+    "\n",
+    "print(\"chat_history\", translator.chat_history)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# <font color=orange> neoLLM 　例\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 1-1 MyLLM (ex. 翻訳)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from neollm import MyLLM\n",
+    "from neollm.utils.preprocess import optimize_token\n",
+    "from neollm.utils.postprocess import strip_string\n",
+    "\n",
+    "\n",
+    "class Translator(MyLLM):\n",
+    "    def _preprocess(self, inputs):\n",
+    "        system_prompt = (\n",
+    "            \"You are a good translator. Translate Japanese into English or English into Japanese.\\n\"\n",
+    "            \"# output_format:\\n<output>\\n{translated text in English or Japanese}\"\n",
+    "        )\n",
+    "        user_prompt = \"<input>\\n\" f\"'''{inputs['text'].strip()}'''\"\n",
+    "        messages = [\n",
+    "            {\"role\": \"system\", \"content\": optimize_token(system_prompt)},\n",
+    "            {\"role\": \"user\", \"content\": optimize_token(user_prompt)},\n",
+    "        ]\n",
+    "        return messages\n",
+    "\n",
+    "    def _ruleprocess(self, inputs):\n",
+    "        # 例外処理\n",
+    "        if inputs[\"text\"].strip() == \"\":\n",
+    "            return {\"text_translated\": \"\"}\n",
+    "        # APIリクエストを送る場合はNone\n",
+    "        return None\n",
+    "\n",
+    "    def _update_settings(self):\n",
+    "        # 入力によってAPIの設定を変更する\n",
+    "\n",
+    "        # トークン数: self.llm.count_tokens(self.messsage)\n",
+    "\n",
+    "        # モデル変更: self.model = \"gpt-3.5-turbo-16k\"\n",
+    "\n",
+    "        # パラメータ変更: self.llm_settings = {\"temperature\": 0.2}\n",
+    "\n",
+    "        # 入力が多い時に16kを使う(1106の場合はやらなくていい)\n",
+    "        if self.messages is not None:\n",
+    "            if self.llm.count_tokens(self.messages) >= 1600:\n",
+    "                self.model = \"gpt-3.5-turbo-16k-0613\"\n",
+    "            else:\n",
+    "                self.model = \"gpt-3.5-turbo-0613\"\n",
+    "\n",
+    "    def _postprocess(self, response):\n",
+    "        text_translated: str = str(response.choices[0].message.content)\n",
+    "        text_translated = strip_string(text=text_translated, first_character=[\"<output>\", \"<outputs>\"])\n",
+    "        outputs = {\"text_translated\": text_translated}\n",
+    "        return outputs"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\u001b[41mPARENT\u001b[0m\n",
+      "MyLLM(Translator) ----------------------------------------------------------------------------------\n",
+      "\u001b[34m[inputs]\u001b[0m\n",
+      "{\n",
+      "  \"text\": \"大規模LLMモデル\"\n",
+      "}\n",
+      "\u001b[34m[messages]\u001b[0m\n",
+      " \u001b[32msystem\u001b[0m\n",
+      "  You are a good translator. Translate Japanese into English or English into Japanese.\n",
+      "  # output_format:\n",
+      "  <output>\n",
+      "  {translated text in English or Japanese}\n",
+      " \u001b[32muser\u001b[0m\n",
+      "  <input>\n",
+      "  '''大規模LLMモデル'''\n",
+      " \u001b[32massistant\u001b[0m\n",
+      "  <output>\n",
+      "  \"Large-Scale LLM Model\"\n",
+      "\u001b[34m[outputs]\u001b[0m\n",
+      "{\n",
+      "  \"text_translated\": \"Large-Scale LLM Model\"\n",
+      "}\n",
+      "\u001b[34m[client_settings]\u001b[0m -\n",
+      "\u001b[34m[llm_settings]\u001b[0m {'platform': 'azure', 'temperature': 1, 'model': 'gpt-3.5-turbo-0613', 'engine': 'neoai-free-swd-gpt-35-0613'}\n",
+      "\u001b[34m[metadata]\u001b[0m 1.5s; 66(55+11)tokens; $9.9e-05; ¥0.014\n",
+      "----------------------------------------------------------------------------------------------------\n",
+      "{'text_translated': 'Large-Scale LLM Model'}\n"
+     ]
+    }
+   ],
+   "source": [
+    "translator = Translator(\n",
+    "    llm_settings={\"temperature\": 1},  # defaultは、{\"temperature\": 0}\n",
+    "    model=\"gpt-3.5-turbo-0613\",  # defaultは、DEFAULT_MODEL_NAME\n",
+    "    platform=\"azure\",  # defaultは、LLM_PLATFORM\n",
+    "    verbose=True,\n",
+    "    silent_list=[],  # 表示しないもの\n",
+    ")\n",
+    "output_1 = translator(inputs={\"text\": \"大規模LLMモデル\"})\n",
+    "print(output_1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\u001b[43mWARNING: model_nameに日付を指定してください\u001b[0m\n",
+      "model_name: gpt-3.5-turbo -> gpt-3.5-turbo-0613\n",
+      "\u001b[41mPARENT\u001b[0m\n",
+      "MyLLM(Translator) ----------------------------------------------------------------------------------\n",
+      "\u001b[34m[inputs]\u001b[0m\n",
+      "{\n",
+      "  \"text\": \"Large LLM Model\"\n",
+      "}\n",
+      "\u001b[34m[messages]\u001b[0m\n",
+      " \u001b[32msystem\u001b[0m\n",
+      "  You are a good translator. Translate Japanese into English or English into Japanese.\n",
+      "  # output_format:\n",
+      "  <output>\n",
+      "  {translated text in English or Japanese}\n",
+      " \u001b[32muser\u001b[0m\n",
+      "  <input>\n",
+      "  '''Large LLM Model'''\n",
+      "\u001b[43mWARNING: model_nameに日付を指定してください\u001b[0m\n",
+      "model_name: gpt-3.5-turbo -> gpt-3.5-turbo-0613\n",
+      " \u001b[32massistant\u001b[0m\n",
+      "  <output>\n",
+      "  大きなLLMモデル\n",
+      "\u001b[34m[outputs]\u001b[0m\n",
+      "{\n",
+      "  \"text_translated\": \"大きなLLMモデル\"\n",
+      "}\n",
+      "\u001b[34m[client_settings]\u001b[0m -\n",
+      "\u001b[34m[llm_settings]\u001b[0m {'platform': 'openai', 'temperature': 0, 'model': 'gpt-3.5-turbo-0613'}\n",
+      "\u001b[34m[metadata]\u001b[0m 0.9s; 61(49+12)tokens; $9.2e-05; ¥0.013\n",
+      "----------------------------------------------------------------------------------------------------\n",
+      "{'text_translated': '大きなLLMモデル'}\n"
+     ]
+    }
+   ],
+   "source": [
+    "translator = Translator(\n",
+    "    platform=\"openai\",  # <- 変えてみる\n",
+    "    verbose=True,\n",
+    ")\n",
+    "output_1 = translator(inputs={\"text\": \"Large LLM Model\"})\n",
+    "print(output_1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\u001b[43mWARNING: model_nameに日��を指定してください\u001b[0m\n",
+      "model_name: gpt-3.5-turbo -> gpt-3.5-turbo-0613\n",
+      "\u001b[41mPARENT\u001b[0m\n",
+      "MyLLM(Translator) ----------------------------------------------------------------------------------\n",
+      "\u001b[34m[inputs]\u001b[0m\n",
+      "{\n",
+      "  \"text\": \"\"\n",
+      "}\n",
+      "\u001b[34m[outputs]\u001b[0m\n",
+      "{\n",
+      "  \"text_translated\": \"\"\n",
+      "}\n",
+      "\u001b[34m[client_settings]\u001b[0m -\n",
+      "\u001b[34m[llm_settings]\u001b[0m {'platform': 'azure', 'temperature': 0, 'model': 'gpt-3.5-turbo-0613', 'engine': 'neoai-free-swd-gpt-35-0613'}\n",
+      "\u001b[34m[metadata]\u001b[0m 0.0s; 0(0+0)tokens; $0; ¥0\n",
+      "----------------------------------------------------------------------------------------------------\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "{'text_translated': ''}"
+      ]
+     },
+     "execution_count": 26,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# ルールベースが起動\n",
+    "data = {\"text\": \"\"}\n",
+    "translator = Translator(verbose=True)\n",
+    "translator(data)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\u001b[43mWARNING: model_nameに日付を指定してください\u001b[0m\n",
+      "model_name: gpt-3.5-turbo -> gpt-3.5-turbo-0613\n",
+      "\u001b[41mPARENT\u001b[0m\n",
+      "MyLLM(Translator) ----------------------------------------------------------------------------------\n",
+      "\u001b[34m[inputs]\u001b[0m\n",
+      "{\n",
+      "  \"text\": \"こんにちは!!\\nこんにちは?こんにちは?\"\n",
+      "}\n",
+      "\u001b[34m[messages]\u001b[0m\n",
+      " \u001b[32msystem\u001b[0m\n",
+      "  You are a good translator. Translate Japanese into English or English into Japanese.\n",
+      "  # output_format:\n",
+      "  <output>\n",
+      "  {translated text in English or Japanese}\n",
+      " \u001b[32muser\u001b[0m\n",
+      "  <input>\n",
+      "  '''こんにちは!!\n",
+      "  こんにちは?こんにちは?'''\n",
+      "\u001b[43mWARNING: model_nameに日付を指定してください\u001b[0m\n",
+      "model_name: gpt-3.5-turbo -> gpt-3.5-turbo-0613\n",
+      " \u001b[32massistant\u001b[0m\n",
+      "  <output>\n",
+      "  Hello!!\n",
+      "  Hello? Hello?\n",
+      "\u001b[34m[outputs]\u001b[0m\n",
+      "{\n",
+      "  \"text_translated\": \"Hello!!\\nHello? Hello?\"\n",
+      "}\n",
+      "\u001b[34m[client_settings]\u001b[0m -\n",
+      "\u001b[34m[llm_settings]\u001b[0m {'platform': 'azure', 'temperature': 0, 'model': 'gpt-3.5-turbo-0613', 'engine': 'neoai-free-swd-gpt-35-0613'}\n",
+      "\u001b[34m[metadata]\u001b[0m 1.4s; 60(51+9)tokens; $9e-05; ¥0.013\n",
+      "----------------------------------------------------------------------------------------------------\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "{'text_translated': 'Hello!!\\nHello? Hello?'}"
+      ]
+     },
+     "execution_count": 27,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "data = {\"text\": \"こんにちは!!\\nこんにちは?こんにちは?\"}\n",
+    "translator = Translator(verbose=True)\n",
+    "translator(data)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 情報抽出\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 50,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from neollm import MyLLM\n",
+    "from neollm.utils.preprocess import optimize_token, dict2json\n",
+    "from neollm.utils.postprocess import json2dict\n",
+    "\n",
+    "\n",
+    "class Extractor(MyLLM):\n",
+    "    def _preprocess(self, inputs):\n",
+    "        system_prompt = \"<INFO>から、<OUTPUT_FORMAT>にしたがって、情報を抽出しなさい。\"\n",
+    "        output_format = {\"date\": \"yy-mm-dd形式 日付\", \"event\": \"起きたことを簡潔に。\"}\n",
+    "        user_prompt = (\n",
+    "            \"<INFO>\\n\"\n",
+    "            \"```\\n\"\n",
+    "            f\"{inputs['info'].strip()}\\n\"\n",
+    "            \"```\\n\"\n",
+    "            \"\\n\"\n",
+    "            \"<OUTPUT_FORMAT>\\n\"\n",
+    "            \"```json\\n\"\n",
+    "            f\"{dict2json(output_format)}\\n\"\n",
+    "            \"```\"\n",
+    "        )\n",
+    "\n",
+    "        messages = [\n",
+    "            {\"role\": \"system\", \"content\": optimize_token(system_prompt)},\n",
+    "            {\"role\": \"user\", \"content\": optimize_token(user_prompt)},\n",
+    "        ]\n",
+    "        return messages\n",
+    "\n",
+    "    def _ruleprocess(self, inputs):\n",
+    "        # 例外処理\n",
+    "        if inputs[\"info\"].strip() == \"\":\n",
+    "            return {\"date\": \"\", \"event\": \"\"}\n",
+    "        # APIリクエストを送る場合はNone\n",
+    "        return None\n",
+    "\n",
+    "    def _postprocess(self, response):\n",
+    "        return json2dict(response.choices[0].message.content)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 51,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\u001b[41mPARENT\u001b[0m\n",
+      "MyLLM(Extractor) -----------------------------------------------------------------------------------\n",
+      "\u001b[34m[inputs]\u001b[0m\n",
+      "{\n",
+      "  \"info\": \"2021年6月13日に、neoAIのサービスが始まりました。\"\n",
+      "}\n",
+      "\u001b[34m[messages]\u001b[0m\n",
+      " \u001b[32msystem\u001b[0m\n",
+      "  <INFO>から、<OUTPUT_FORMAT>にしたがって、情報を抽出しなさい。\n",
+      " \u001b[32muser\u001b[0m\n",
+      "  <INFO>\n",
+      "  ```\n",
+      "  2021年6月13日に、neoAIのサービスが始まりました。\n",
+      "  ```\n",
+      "  \n",
+      "  <OUTPUT_FORMAT>\n",
+      "  ```json\n",
+      "  {\n",
+      "    \"date\": \"yy-mm-dd形式 日付\",\n",
+      "    \"event\": \"起きたことを簡潔に。\"\n",
+      "  }\n",
+      "  ```\n",
+      " \u001b[32massistant\u001b[0m\n",
+      "  ```json\n",
+      "  {\n",
+      "    \"date\": \"2021-06-13\",\n",
+      "    \"event\": \"neoAIのサービスが始まりました。\"\n",
+      "  }\n",
+      "  ```\n",
+      "\u001b[34m[outputs]\u001b[0m\n",
+      "{\n",
+      "  \"date\": \"2021-06-13\",\n",
+      "  \"event\": \"neoAIのサービスが始まりました。\"\n",
+      "}\n",
+      "\u001b[34m[client_settings]\u001b[0m -\n",
+      "\u001b[34m[llm_settings]\u001b[0m {'platform': 'azure', 'temperature': 0, 'model': 'gpt-3.5-turbo-0613', 'engine': 'neoai-free-swd-gpt-35-0613'}\n",
+      "\u001b[34m[metadata]\u001b[0m 1.6s; 143(106+37)tokens; $0.00021; ¥0.03\n",
+      "----------------------------------------------------------------------------------------------------\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "{'date': '2021-06-13', 'event': 'neoAIのサービスが始まりました。'}"
+      ]
+     },
+     "execution_count": 51,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "extractor = Extractor(model=\"gpt-3.5-turbo-0613\")\n",
+    "\n",
+    "extractor(inputs={\"info\": \"2021年6月13日に、neoAIのサービスが始まりました。\"})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 52,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\u001b[41mPARENT\u001b[0m\n",
+      "MyLLM(Extractor) -----------------------------------------------------------------------------------\n",
+      "\u001b[34m[inputs]\u001b[0m\n",
+      "{\n",
+      "  \"info\": \"1998年4月1日に、neoAI大学が設立されました。\"\n",
+      "}\n",
+      "\u001b[34m[messages]\u001b[0m\n",
+      " \u001b[32msystem\u001b[0m\n",
+      "  <INFO>から、<OUTPUT_FORMAT>にしたがって、情報を抽出しなさい。\n",
+      " \u001b[32muser\u001b[0m\n",
+      "  <INFO>\n",
+      "  ```\n",
+      "  1998年4月1日に、neoAI大学が設立されました。\n",
+      "  ```\n",
+      "  \n",
+      "  <OUTPUT_FORMAT>\n",
+      "  ```json\n",
+      "  {\n",
+      "    \"date\": \"yy-mm-dd形式 日付\",\n",
+      "    \"event\": \"起きたことを簡潔に。\"\n",
+      "  }\n",
+      "  ```\n",
+      " \u001b[32massistant\u001b[0m\n",
+      "  <OUTPUT>\n",
+      "  ```json\n",
+      "  {\n",
+      "    \"date\": \"1998-04-01\",\n",
+      "    \"event\": \"neoAI大学の設立\"\n",
+      "  }\n",
+      "  ```\n",
+      "\u001b[34m[outputs]\u001b[0m\n",
+      "{\n",
+      "  \"date\": \"1998-04-01\",\n",
+      "  \"event\": \"neoAI大学の設立\"\n",
+      "}\n",
+      "\u001b[34m[client_settings]\u001b[0m -\n",
+      "\u001b[34m[llm_settings]\u001b[0m {'platform': 'azure', 'temperature': 0, 'model': 'gpt-3.5-turbo-0613', 'engine': 'neoai-free-swd-gpt-35-0613'}\n",
+      "\u001b[34m[metadata]\u001b[0m 1.6s; 139(104+35)tokens; $0.00021; ¥0.029\n",
+      "----------------------------------------------------------------------------------------------------\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "{'date': '1998-04-01', 'event': 'neoAI大学の設立'}"
+      ]
+     },
+     "execution_count": 52,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "extractor = Extractor(model=\"gpt-3.5-turbo-0613\")\n",
+    "\n",
+    "extractor(inputs={\"info\": \"1998年4月1日に、neoAI大学が設立されました。\"})"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.11"
+  },
+  "orig_nbformat": 4
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

pyproject.toml

@@ -0,0 +1,81 @@
+[tool.poetry]
+name = "neollm"
+version = "1.3.3"
+description = "neo LLM Module for Python 3.10"
+authors = ["KoshiroTerasawa <k.terasawa@neoai.jp>"]
+readme = "README.md"
+packages = [{ include = "neollm" }]
+
+[tool.poetry.dependencies]
+python = "^3.10"
+python-dotenv = "^1.0.0"
+pydantic = "^2.4.2"
+openai = "^1.1.1"
+google-cloud-aiplatform = "^1.48.0"
+anthropic = { version = "^0.18.1", extras = ["vertex"] }
+typing-extensions = "^4.8.0"
+google-generativeai = "0.5.2"
+tiktoken = "0.7.0"
+
+
+[tool.poetry.group.dev.dependencies]
+isort = "^5.12.0"
+black = "24.3.0"
+mypy = "^1.8.0"
+pyproject-flake8 = "^6.1.0"
+ipykernel = "^6.26.0"
+jupyter = "^1.0.0"
+jupyter-client = "^8.6.0"
+pytest = "^8.1.1"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.black]
+line-length = 119
+exclude = '''
+/(
+    \venv
+  | \.git
+  | \.hg
+  | __pycache__
+  | \.mypy_cache
+)/
+'''
+
+[tool.isort]
+profile = "black"
+multi_line_output = 3
+
+[tool.flake8]
+max-line-length = 119
+extend-ignore = ["E203", "W503", "E501", "E704"]
+exclude = [".venv", ".git", "__pycache__", ".mypy_cache", ".hg"]
+max-complexity = 15
+
+[tool.mypy]
+ignore_missing_imports = true
+# follow_imports = normal
+disallow_any_unimported = false
+disallow_any_expr = false       # 式でのAny禁止
+disallow_any_decorated = false
+disallow_any_explicit = false   # 変数でAny禁止
+disallow_any_generics = true    # ジェネリックで書かないの禁止
+disallow_subclassing_any = true # Anyのサブクラス禁止
+
+disallow_untyped_calls = true      # 型なし関数呼び出し禁止 `a: int = f()`
+disallow_untyped_defs = true       # 型なし関数定義禁止 `def f(a: int) -> int`
+disallow_incomplete_defs = true    # 一部の型定義を禁止 `def f(a: int, b)`
+check_untyped_defs = true
+disallow_untyped_decorators = true
+no_implicit_optional = true
+
+warn_redundant_casts = true
+warn_unused_ignores = true
+warn_return_any = true
+warn_unreachable = true     # 辿りつかないコードの検出
+allow_redefinition = false  # 変数の再定義を禁止
+
+show_error_context = true
+show_column_numbers = true

test/llm/claude/test_claude_llm.py

@@ -0,0 +1,37 @@
+# from neollm.llm.gpt.azure_llm import (
+#     AzureGPT4_0613,
+#     AzureGPT4T_0125,
+#     AzureGPT4T_1106,
+#     AzureGPT4T_20240409,
+#     AzureGPT4VT_1106,
+#     AzureGPT35FT,
+#     AzureGPT35T16k_0613,
+#     AzureGPT35T_0125,
+#     AzureGPT35T_0613,
+#     AzureGPT35T_1106,
+#     AzureGPT432k_0613,
+# )
+# from neollm.types.info import APIPricing
+
+
+# def test_check_price() -> None:
+#     # https://azure.microsoft.com/ja-jp/pricing/details/cognitive-services/openai-service/
+
+#     # これからのモデル --------------------------------------------------------
+#     assert AzureGPT4T_20240409.dollar_per_ktoken == APIPricing(input=0.01, output=0.03)
+#     # Updated --------------------------------------------------------
+#     # GPT3.5T
+#     assert AzureGPT35T_0125.dollar_per_ktoken == APIPricing(input=0.0005, output=0.0015)
+#     # GPT4
+#     assert AzureGPT4T_0125.dollar_per_ktoken == APIPricing(input=0.01, output=0.03)
+#     assert AzureGPT4VT_1106.dollar_per_ktoken == APIPricing(input=0.01, output=0.03)
+#     assert AzureGPT4T_1106.dollar_per_ktoken == APIPricing(input=0.01, output=0.03)
+#     assert AzureGPT4_0613.dollar_per_ktoken == APIPricing(input=0.03, output=0.06)
+#     assert AzureGPT432k_0613.dollar_per_ktoken == APIPricing(input=0.06, output=0.12)
+#     # FT
+#     assert AzureGPT35FT.dollar_per_ktoken == APIPricing(input=0.0005, output=0.0015)
+#     # Legacy ---------------------------------------------------------
+#     # AzureGPT35T_0301 なし
+#     assert AzureGPT35T_0613.dollar_per_ktoken == APIPricing(input=0.0015, output=0.002)
+#     assert AzureGPT35T16k_0613.dollar_per_ktoken == APIPricing(input=0.003, output=0.004)
+#     assert AzureGPT35T_1106.dollar_per_ktoken == APIPricing(input=0.001, output=0.002)

test/llm/gpt/test_azure_llm.py

@@ -0,0 +1,92 @@
+from neollm.llm.gpt.azure_llm import (
+    AzureGPT4_0613,
+    AzureGPT4O_20240513,
+    AzureGPT4T_0125,
+    AzureGPT4T_1106,
+    AzureGPT4T_20240409,
+    AzureGPT4VT_1106,
+    AzureGPT35FT,
+    AzureGPT35T16k_0613,
+    AzureGPT35T_0125,
+    AzureGPT35T_0613,
+    AzureGPT35T_1106,
+    AzureGPT432k_0613,
+    get_azure_llm,
+)
+from neollm.types.info import APIPricing
+
+
+def test_get_azure_llm() -> None:
+
+    # no date
+    assert get_azure_llm("gpt-3.5-turbo", {}).__class__ == AzureGPT35T_0613
+    assert get_azure_llm("gpt-35-turbo", {}).__class__ == AzureGPT35T_0613
+    assert get_azure_llm("gpt-3.5-turbo-16k", {}).__class__ == AzureGPT35T16k_0613
+    assert get_azure_llm("gpt-35-turbo-16k", {}).__class__ == AzureGPT35T16k_0613
+    assert get_azure_llm("gpt-4", {}).__class__ == AzureGPT4_0613
+    assert get_azure_llm("gpt-4-32k", {}).__class__ == AzureGPT432k_0613
+    assert get_azure_llm("gpt-4-turbo", {}).__class__ == AzureGPT4T_1106
+    assert get_azure_llm("gpt-4v-turbo", {}).__class__ == AzureGPT4VT_1106
+    assert get_azure_llm("gpt-4o", {}).__class__ == AzureGPT4O_20240513
+    # with date
+    assert get_azure_llm("gpt-4o-2024-05-13", {}).__class__ == AzureGPT4O_20240513
+    assert get_azure_llm("gpt-4-turbo-2024-04-09", {}).__class__ == AzureGPT4T_20240409
+    assert get_azure_llm("gpt-3.5-turbo-0125", {}).__class__ == AzureGPT35T_0125
+    assert get_azure_llm("gpt-35-turbo-0125", {}).__class__ == AzureGPT35T_0125
+    assert get_azure_llm("gpt-4-turbo-0125", {}).__class__ == AzureGPT4T_0125
+    assert get_azure_llm("gpt-3.5-turbo-1106", {}).__class__ == AzureGPT35T_1106
+    assert get_azure_llm("gpt-35-turbo-1106", {}).__class__ == AzureGPT35T_1106
+    assert get_azure_llm("gpt-4-turbo-1106", {}).__class__ == AzureGPT4T_1106
+    assert get_azure_llm("gpt-4v-turbo-1106", {}).__class__ == AzureGPT4VT_1106
+    assert get_azure_llm("gpt-3.5-turbo-0613", {}).__class__ == AzureGPT35T_0613
+    assert get_azure_llm("gpt-35-turbo-0613", {}).__class__ == AzureGPT35T_0613
+    assert get_azure_llm("gpt-3.5-turbo-16k-0613", {}).__class__ == AzureGPT35T16k_0613
+    assert get_azure_llm("gpt-35-turbo-16k-0613", {}).__class__ == AzureGPT35T16k_0613
+    assert get_azure_llm("gpt-4-0613", {}).__class__ == AzureGPT4_0613
+    assert get_azure_llm("gpt-4-32k-0613", {}).__class__ == AzureGPT432k_0613
+    # ft
+    assert get_azure_llm("ft:gpt-3.5-turbo-1106-XXXX", {}).__class__ == AzureGPT35FT
+
+
+def test_check_price() -> None:
+    # https://azure.microsoft.com/ja-jp/pricing/details/cognitive-services/openai-service/
+
+    # これからのモデル --------------------------------------------------------
+    assert AzureGPT4T_20240409.dollar_per_ktoken == APIPricing(input=0.01, output=0.03)
+    # Updated --------------------------------------------------------
+    # GPT3.5T
+    assert AzureGPT35T_0125.dollar_per_ktoken == APIPricing(input=0.0005, output=0.0015)
+    # GPT4
+    assert AzureGPT4O_20240513.dollar_per_ktoken == APIPricing(input=0.005, output=0.015)
+    assert AzureGPT4T_0125.dollar_per_ktoken == APIPricing(input=0.01, output=0.03)
+    assert AzureGPT4VT_1106.dollar_per_ktoken == APIPricing(input=0.01, output=0.03)
+    assert AzureGPT4T_1106.dollar_per_ktoken == APIPricing(input=0.01, output=0.03)
+    assert AzureGPT4_0613.dollar_per_ktoken == APIPricing(input=0.03, output=0.06)
+    assert AzureGPT432k_0613.dollar_per_ktoken == APIPricing(input=0.06, output=0.12)
+    # FT
+    assert AzureGPT35FT.dollar_per_ktoken == APIPricing(input=0.0005, output=0.0015)
+    # Legacy ---------------------------------------------------------
+    # AzureGPT35T_0301 なし
+    assert AzureGPT35T_0613.dollar_per_ktoken == APIPricing(input=0.0015, output=0.002)
+    assert AzureGPT35T16k_0613.dollar_per_ktoken == APIPricing(input=0.003, output=0.004)
+    assert AzureGPT35T_1106.dollar_per_ktoken == APIPricing(input=0.001, output=0.002)
+
+
+def test_check_context_window() -> None:
+    # https://learn.microsoft.com/ja-jp/azure/ai-services/openai/concepts/models#gpt-4-and-gpt-4-turbo-preview-models
+    assert AzureGPT4T_20240409.context_window == 128_000
+
+    assert AzureGPT4T_0125.context_window == 128_000
+    assert AzureGPT35T_0125.context_window == 16_385
+
+    assert AzureGPT4O_20240513.context_window == 128_000
+    assert AzureGPT4T_1106.context_window == 128_000
+    assert AzureGPT4VT_1106.context_window == 128_000
+    assert AzureGPT35T_1106.context_window == 16_385
+
+    assert AzureGPT35T_0613.context_window == 4_096
+    assert AzureGPT4_0613.context_window == 8_192
+    assert AzureGPT35T16k_0613.context_window == 16_385
+    assert AzureGPT432k_0613.context_window == 32_768
+
+    assert AzureGPT35FT.context_window == 4_096

test/llm/gpt/test_openai_llm.py

@@ -0,0 +1,37 @@
+# from neollm.llm.gpt.azure_llm import (
+#     AzureGPT4_0613,
+#     AzureGPT4T_0125,
+#     AzureGPT4T_1106,
+#     AzureGPT4T_20240409,
+#     AzureGPT4VT_1106,
+#     AzureGPT35FT,
+#     AzureGPT35T16k_0613,
+#     AzureGPT35T_0125,
+#     AzureGPT35T_0613,
+#     AzureGPT35T_1106,
+#     AzureGPT432k_0613,
+# )
+# from neollm.types.info import APIPricing
+
+
+# def test_check_price() -> None:
+#     # https://azure.microsoft.com/ja-jp/pricing/details/cognitive-services/openai-service/
+
+#     # これからのモデル --------------------------------------------------------
+#     assert AzureGPT4T_20240409.dollar_per_ktoken == APIPricing(input=0.01, output=0.03)
+#     # Updated --------------------------------------------------------
+#     # GPT3.5T
+#     assert AzureGPT35T_0125.dollar_per_ktoken == APIPricing(input=0.0005, output=0.0015)
+#     # GPT4
+#     assert AzureGPT4T_0125.dollar_per_ktoken == APIPricing(input=0.01, output=0.03)
+#     assert AzureGPT4VT_1106.dollar_per_ktoken == APIPricing(input=0.01, output=0.03)
+#     assert AzureGPT4T_1106.dollar_per_ktoken == APIPricing(input=0.01, output=0.03)
+#     assert AzureGPT4_0613.dollar_per_ktoken == APIPricing(input=0.03, output=0.06)
+#     assert AzureGPT432k_0613.dollar_per_ktoken == APIPricing(input=0.06, output=0.12)
+#     # FT
+#     assert AzureGPT35FT.dollar_per_ktoken == APIPricing(input=0.0005, output=0.0015)
+#     # Legacy ---------------------------------------------------------
+#     # AzureGPT35T_0301 なし
+#     assert AzureGPT35T_0613.dollar_per_ktoken == APIPricing(input=0.0015, output=0.002)
+#     assert AzureGPT35T16k_0613.dollar_per_ktoken == APIPricing(input=0.003, output=0.004)
+#     assert AzureGPT35T_1106.dollar_per_ktoken == APIPricing(input=0.001, output=0.002)

test/llm/platform.py

@@ -0,0 +1,32 @@
+import pytest
+
+from neollm.llm.platform import Platform
+
+
+class TestPlatform:
+    def test_str(self) -> None:
+        assert Platform.AZURE == "azure"  # type: ignore
+        assert Platform.OPENAI == "openai"  # type: ignore
+        assert Platform.ANTHROPIC == "anthropic"  # type: ignore
+        assert Platform.GCP == "gcp"  # type: ignore
+
+    def test_init(self) -> None:
+        assert Platform("azure") == Platform.AZURE
+        assert Platform("openai") == Platform.OPENAI
+        assert Platform("anthropic") == Platform.ANTHROPIC
+        assert Platform("gcp") == Platform.GCP
+
+        assert Platform("Azure  ") == Platform.AZURE
+        assert Platform(" OpenAI") == Platform.OPENAI
+        assert Platform("Anthropic ") == Platform.ANTHROPIC
+        assert Platform("GcP") == Platform.GCP
+
+    def test_from_string(self) -> None:
+        assert Platform.from_string("azure") == Platform.AZURE
+        assert Platform.from_string("openai") == Platform.OPENAI
+        assert Platform.from_string("anthropic") == Platform.ANTHROPIC
+        assert Platform.from_string("gcp") == Platform.GCP
+
+    def test_from_string_error(self) -> None:
+        with pytest.raises(ValueError):
+            Platform.from_string("error")