import openai
import json
 
# 天気を返す関数（仮）。実際はここで外部APIなどに問い合わせする。
def get_current_weather(location):
    weather_info = {
        "location": location,
        "temperature": "24度",
        "forecast": "晴れ",
    }
    return json.dumps(weather_info)
 
# 関数を動的に取得するための辞書
available_functions = {
    "get_current_weather": get_current_weather,
}
 
def run_conversation(prompt:str):
    # Step 1: 会話と利用可能な機能をGPTに送信
    messages = [{"role": "user", "content": prompt}]
    functions = [
        {
            "name": "get_current_weather", # 関数名
            "description": "指定した場所の現在の天気を取得する", # 関数の説明
            "parameters": { # 関数の引数。JSON Schemaで記述。https://json-schema.org/understanding-json-schema/
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "場所。例：東京, 大阪, 福岡, など",
                    },
                },
                "required": ["location"],
            },
        }
    ]
    response = openai.ChatCompletion.create(
        model="gpt-3.5-turbo-0613",
        messages=messages,
        functions=functions,
        function_call="auto"
    )
    response_message = response["choices"][0]["message"]
 
    # Step 2: GPTが関数を呼び出したいかチェックする
    if response_message.get("function_call"):
        # Step 3: 関数を呼び出す
        function_name = response_message["function_call"]["name"]
        function_args = json.loads(response_message["function_call"]["arguments"])
        function_response = available_functions[function_name](**function_args)
 
        # Step 4: 関数コールと関数のレスポンスをGPTに送信し、再度回答を得る。
        messages.append(response_message)
        messages.append(
            {
                "role": "function",
                "name": function_name,
                "content": function_response,
            }
        )
        second_response = openai.ChatCompletion.create(
            model="gpt-3.5-turbo-0613",
            messages=messages,
        )
        print(json.dumps(messages, indent=4, ensure_ascii=False))
        return second_response["choices"][0]["message"]["content"]
 
# 実行
print(run_conversation("今日の東京の天気は？"))
 
# 出力結果
# 今日の東京の天気は晴れで、気温は24度です。

python -m venv venv
venv\scripts\activate
pip install -U openai[datalib]

cd C:\Program Files\Autodesk\Maya2024\bin
mayapy -m pip install -U openai[datalib] -t C:\Users\ユーザー名\Documents\maya\2024\scripts\site-packages
 

import sys
import traceback
from typing import List
from maya import cmds
 
class FunctionSet:
 
    def __init__(self):
        self.functions = [
            {
                "name": "search_manual",
                "description": "リグの取り扱いマニュアルから関連する情報を検索します。マニュアルにはリグコントローラ名とその機能、その他の補助機能の概要が書いてあります。",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "query": {
                            "type": "string",
                            "description": "マニュアルからどのような内容の関連文書を取得したいかの検索語句",
                        },
                    },
                    "required": ["query"],
                },
            },
            {
                "name": "select_ctls",
                "description": "指定した名前のリグコントローラを選択する。複数可。",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "ctl_list": {
                            "type": "array",
                            "description": "リグコントローラ名の配列",
                            "items": {
                                "type": "string",
                            },
                        },
                    },
                    "required": ["ctl_list"],
                },
            },
            {
                "name": "set_attribute",
                "description": "指定した名前のリグコントローラの、指定したアトリビュートを、指定した値に設定する。複数可。コントローラを選択している必要はない。",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "attribute_data_list":{
                            "type": "array",
                            "items": {
                                "type": "array",
                                "items": {
                                    "ctl_name":{
                                        "type": "string",
                                        "description": "リグコントローラ名",
                                    },
                                    "attribute_name":{
                                        "type": "string",
                                        "description": "アトリビュート名",
                                    },
                                    "value":{
                                        "type": "string",
                                        "description": "設定値",
                                    },
                                },
                                "minItems": 3,
                                "maxItems": 3
                            },
                        },
                    },
                    "required": ["attribute_data_list"],
                },
            },
            {
                "name": "get_attribute_value",
                "description": "指定した名前のリグコントローラの、指定したアトリビュートの値を取得する。複数可。コントローラを選択している必要はない。",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "attribute_data_list":{
                            "type": "array",
                            "items": {
                                "type": "array",
                                "items": {
                                    "ctl_name":{
                                        "type": "string",
                                        "description": "リグコントローラ名",
                                    },
                                    "attribute_name":{
                                        "type": "string",
                                        "description": "アトリビュート名",
                                    },
                                },
                                "minItems": 2,
                                "maxItems": 2
                            },
                        },
                    },
                    "required": ["attribute_data_list"],
                },
            },
            {
                "name": "exec_code",
                "description": "pythonスクリプトを実行します。",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "code": {
                            "type": "string",
                            "description": "pythonコード",
                        },
                    },
                    "required": ["code"],
                },
            },
        ]
 
 
    # 既存の知識に無い部分を補う
    def search_manual(self, query:str):
        """ マニュアルから検索語句(query)に該当する箇所を取得する """
        # 次項で
        pass
 
    # Mayaから情報を得る／操作する
    def select_ctls(self, ctl_list:List[str]):
        """ 指定したノードを選択する """
        msg = []
        for ctl in ctl_list:
            if not cmds.objExists(ctl):
                msg.append("{}というコントローラは無い。".format(ctl))
        if msg:
            msg.append("マニュアルを確認し正しいコントローラ名を得る必要がある。")
            return "\n".join(msg)
    
        cmds.select(ctl_list)
        return "{}を選択した。".format(",".join(ctl_list))
 
    def set_attribute(self, attribute_data_list:List[List]):
        """ 指定したノードの指定したアトリビュートを指定値にセットする """        
        msg = []
        for ctl, attr, value in attribute_data_list:
            full_attr = ctl + "." + attr
            if not cmds.objExists(ctl):
                msg.append("{}というコントローラは無い。マニュアルを確認し正しいコントローラ名を得る必要がある。".format(ctl))
            elif not cmds.objExists(full_attr):
                msg.append("{}に{}というアトリビュートはない。マニュアルを確認し正しいアトリビュート名を得る必要がある。".format(ctl, attr))
            else:
                if type(value) == str:
                    value = self._convert_str(value)
                if type(value) == str:
                    cmds.setAttr(full_attr, value, type="string")
                else:
                    cmds.setAttr(full_attr, value)
                msg.append("{}を{}に設定した。".format(full_attr, value))
 
        return "\n".join(msg)
 
    def get_attribute_value(self, attribute_data_list:List[List]):
        """ 指定したノードの指定したアトリビュートの現在値を取得する """
        msg = []
        for ctl, attr in attribute_data_list:
            full_attr = ctl + "." + attr
            if not cmds.objExists(ctl):
                msg.append("{}というコントローラは無い。マニュアルを確認し正しいコントローラ名を得る必要がある。".format(ctl))
            elif not cmds.objExists(full_attr):
                msg.append("{}に{}というアトリビュートはない。マニュアルを確認し正しいアトリビュート名を得る必要がある。".format(ctl, attr))
            else:
                value = cmds.getAttr(full_attr)
                msg.append("{}の現在の値は{}。".format(full_attr, value))
 
        return "\n".join(msg)
 
    def exec_code(self, code:str):
        """ pythonコードを実行する関数 エラーが発生したらエラー文を返す """
        try:
            exec(code, {'__name__': '__main__'}, None)
            return 'pythonコード実行完了'
        except Exception:
            exc_type, exc_value, exc_traceback = sys.exc_info()
            trace = traceback.format_exception(exc_type, exc_value, exc_traceback)
            return "{}: {}: {}".format(exc_type.__name__, trace[-2].strip(), exc_value)
 
    def _convert_str(self, s:str):
        """ 文字列の内容に基づいて適切な型(bool, int, float, str)に変換する """
        if s.lower() == "true":
            return True
        elif s.lower() == "false":
            return False
    
        try:
            return int(s)
        except ValueError:
            pass
    
        try:
            return float(s)
        except ValueError:
            pass
    
        return s

import numpy as np
import openai
 
def get_embedding(text:str, engine="text-embedding-ada-002", **kwargs):
    """ 与えられたテキストの埋め込みベクトルを取得する """
    return openai.Embedding.create(input=[text], engine=engine, **kwargs)["data"][0]["embedding"]
 
def cosine_similarity(a, b):
    """ 2つのベクトル間のコサイン類似度を計算する """
    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))
 
# テキストのリスト
texts = ["動物","植物","乗り物","建物"]
 
# 各テキストの埋め込みベクトルを取得し、辞書のリストとして保存する
embeddings = [{"text": t, "embedding": get_embedding(t)} for t in texts]
 
# クエリの埋め込みベクトルを取得する
query_embedding = get_embedding("猫")
 
# クエリの埋め込みベクトルと各テキストの埋め込みベクトルとのコサイン類似度を計算する
scores = [(data["text"], cosine_similarity(query_embedding, data["embedding"])) for data in embeddings]
 
# 類似度の高い順にソートする
sorted_scores = sorted(scores, key=lambda x: x[1], reverse=True)
 
# ソートされた結果を表示する
for s in sorted_scores:
    print(s)
 
# 出力:
# ('動物', 0.8673454180180918)
# ('植物', 0.8389430771237997)
# ('建物', 0.8142869467061629)
# ('乗り物', 0.7896206872541609)

from pathlib import Path
from typing import List, Dict
import json
import openai
 
def get_embeddings(
    list_of_text: List[str], engine="text-embedding-ada-002", **kwargs
) -> List[List[float]]:
    assert len(list_of_text) <= 2048, "The batch size should not be larger than 2048."
 
 
    # replace newlines, which can negatively affect performance.
    list_of_text = [text.replace("\n", " ") for text in list_of_text]
 
 
    data = openai.Embedding.create(input=list_of_text, engine=engine, **kwargs).data
    return [d["embedding"] for d in data]
 
def texts_to_vectorstore(text_path: Path):
    """ 指定されたテキストファイルをベクトルストアに変換 """
 
 
    # テキストファイルを読み取る。
    with open(text_path, 'r', encoding="utf-8") as f:
        text = f.read()
 
 
    # テキストを個々のテキストに分割。
    texts = [t.strip() for t in text.split("\n\n\n") if t.strip()]
 
    # 各テキストの埋め込みを取得。
    embeddings = get_embeddings(texts)
 
 
    # ベクトルストアデータを準備。
    vector_store = []
    for i, t in enumerate(texts):
        vector_store.append(
            {
                "content": t,
                "embedding": embeddings[i],
            }
        )
 
 
    # ベクトルストアをJSONファイルとして保存。
    with open(text_path.with_suffix('.json'), mode="w", encoding="utf-8") as f:
        json.dump(vector_store, f, ensure_ascii=False)
 
 
texts_to_vectorstore(Path("./rig_manual.txt"))

from pathlib import Path
from typing import List, Tuple
import json
import numpy as np
import openai
 
class VectorStore:
    """
    ベクトルストアを管理するクラス。テキストの埋め込みを取得し、類似度検索を行う機能を提供。
    """
 
 
    def __init__(self, path: Path) -> None:
        with open(path, mode="r", encoding="utf-8") as f:
            self.vector_store = json.load(f)
 
 
    def _get_embedding(self, text: str, engine="text-embedding-ada-002", **kwargs) -> List[float]:
        """ 指定されたテキストの埋め込みを取得 """
        text = text.replace("\n", " ")
        return openai.Embedding.create(input=[text], engine=engine, **kwargs)["data"][0]["embedding"]
 
 
    def _cosine_similarity(self, a, b):
        """ 2つのベクトル間のコサイン類似度を計算 """
        return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))
 
 
    def similarity_search(self, query: str, k: int = 4) -> List[Tuple]:
        """ 与えられたクエリに基づいて、ベクトルストア内のテキストとの類似度を計算し、上位k件の最も類似度が高いテキストとそのスコアを返す。 """
        query_embedding = self._get_embedding(query)
        scores = [(data, self._cosine_similarity(query_embedding, data["embedding"])) for data in self.vector_store]
        sorted_scores = sorted(scores, key=lambda x: x[1], reverse=True)
        return sorted_scores[:k]

class FunctionSet:
 
    def __init__(self, manual_vs:VectorStore):
        self.manual_vs = manual_vs
 
        self.functions = [
            ## 中略 ##
        ]
    
    # 既存の知識に無い部分を補う
    def search_manual(self, query:str):
        """ マニュアルから検索語句(query)に該当する箇所を取得する """
        search_result = self.manual_vs.similarity_search(query)
        return "\n".join([sr[0]["content"] for sr in search_result])
 
    ## 以下略 ##

from typing import List
import json
import openai
 
class Agent:
 
    def __init__(self, function_set:FunctionSet):
        self.func_set = function_set  
        self.system_prompt = """あなたはある特定のキャラクターリグの取り扱いをサポートする優秀なAIです。
質問に対し、必ずマニュアル内を検索し該当する記述があるかを確認してから返答してください。
一般的な既存の知識だけで返答することがないよう徹底してください。
不足している情報があれば無理に回答せず、ユーザーへ質問を返してください。"""
 
    def __call__(self, query:str, messages:List=[], model:str="gpt-3.5-turbo-0613", max_call:int=10, **kwargs):
 
        print("-------------")
        print("user: ", query)
    
        if len(messages) == 0:
            # メッセージが空だった場合（会話の最初だった場合）はmessagesにシステムプロンプト追加
            messages.append({"role": "system", "content": self.system_prompt})
    
        # ユーザーの問い合わせをmessagesに追加
        messages.append({"role": "user", "content": query})
 
        for i in range(max_call):
 
            # ターン数表示
            print("---- [{}] ----".format(i))
 
            # APIリクエスト
            finish_reason, message = self.chat_completion_with_functions(messages, model, **kwargs)
 
            if finish_reason == "function_call":
                ### function 使う場合 ###
 
                # 関数名と引数取得
                func_name = message["function_call"]["name"]
                arguments = json.loads(message["function_call"]["arguments"])
                print("call <{}> args={}".format(func_name, arguments))
 
                # 関数セットから関数を取得し、引数を渡して実行
                func_returns = getattr(self.func_set, func_name)(**arguments)
                print(func_returns)
 
                # messagesに返答と関数の実行結果を追加
                messages.append(message)
                messages.append({"role": "function", "name": func_name, "content": func_returns})
            else:
                ### function 使わない場合 ###
 
                # messagesに返答を追加して終了
                messages.append(message)
                print("agent: ", message["content"].strip())
 
                break
 
        return messages
 
    def chat_completion_with_functions(self, messages:List, model:str, **kwargs):
        response = openai.ChatCompletion.create(
            model=model,
            messages=messages,
            temperature=0,
            top_p=1,
            functions=self.func_set.functions,
            function_call="auto",
            **kwargs
        )
 
        finish_reason = response.choices[0]["finish_reason"]
        message = response.choices[0]["message"]
    
        return finish_reason, message

from pathlib import Path
from maya import cmds, OpenMayaUI
from PySide2 import QtWidgets
from shiboken2 import wrapInstance
 
class InputDialog(QtWidgets.QDialog):
    def __init__(self, parent=None):
        super(InputDialog, self).__init__(parent)
        self.line_edit = QtWidgets.QLineEdit(self)
        self.line_edit.setStyleSheet("QLineEdit {font-size: 15px;}")
        self.ok_button = QtWidgets.QPushButton('Send', self)
        self.ok_button.clicked.connect(self.accept)
        self.layout = QtWidgets.QVBoxLayout(self)
        self.layout.addWidget(self.line_edit)
        self.layout.addWidget(self.ok_button)
 
    def show(self):
        super(InputDialog, self).show()
        if self.exec_():
            return self.line_edit.text()
 
if __name__ == "__main__":
 
    # VectorStore読み込み
    manual_vs = VectorStore(Path("./rig_manual.json"))
 
    # 関数セットのインスタンスを作成
    function_set = FunctionSet(manual_vs=manual_vs)
 
    # エージェントのインスタンスを作成
    agent = Agent(function_set=function_set)
 
    # 初期の空メッセージリスト
    messages = []
 
    input_dialog = InputDialog(wrapInstance(int(OpenMayaUI.MQtUtil.mainWindow()), QtWidgets.QWidget))
 
    while True:
        user_input = input_dialog.show()
 
        if user_input is None:
            break
 
        if not user_input:
            continue
    
        # エージェントへ問い合わせて更新されたメッセージを受け取る
        messages = agent(query=user_input, messages=messages, model="gpt-4-0613", max_call=20)
 
        cmds.refresh()