pycoze 0.1.20__tar.gz → 0.1.23__tar.gz

{pycoze-0.1.20 → pycoze-0.1.23}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pycoze
-Version: 0.1.20
+Version: 0.1.23
 Summary: Package for pycoze only!
 Author: Yuan Jie Xiong
 Author-email: aiqqqqqqq@qq.com

{pycoze-0.1.20 → pycoze-0.1.23}/pycoze.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pycoze
-Version: 0.1.20
+Version: 0.1.23
 Summary: Package for pycoze only!
 Author: Yuan Jie Xiong
 Author-email: aiqqqqqqq@qq.com

pycoze-0.1.23/pycoze.egg-info/SOURCES.txt

@@ -0,0 +1,7 @@
+LICENSE
+README.md
+setup.py
+pycoze.egg-info/PKG-INFO
+pycoze.egg-info/SOURCES.txt
+pycoze.egg-info/dependency_links.txt
+pycoze.egg-info/top_level.txt

pycoze-0.1.23/pycoze.egg-info/top_level.txt

@@ -0,0 +1 @@
+

{pycoze-0.1.20 → pycoze-0.1.23}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="pycoze",
-    version="0.1.20",
+    version="0.1.23",
     packages=find_packages(),
     install_requires=[],
     author="Yuan Jie Xiong",

pycoze-0.1.20/pycoze/__init__.py

@@ -1,4 +0,0 @@
-from . import bot
-from . import gpu
-from . import ui
-from . import utils

pycoze-0.1.20/pycoze/bot/__init__.py

@@ -1 +0,0 @@
-from .bot import chat

pycoze-0.1.20/pycoze/bot/agent/__init__.py

@@ -1,5 +0,0 @@
-from .agent import run_agent
-from .assistant import Runnable
-from .chat import  INPUT_MESSAGE, output
-
-__all__ = [run_agent, Runnable, INPUT_MESSAGE, output]

pycoze-0.1.20/pycoze/bot/agent/agent.py

@@ -1,72 +0,0 @@
-import asyncio
-import json
-from langchain_openai import ChatOpenAI
-from .chat import info
-from .assistant import Runnable
-from langchain_core.messages import  HumanMessage, AIMessage,AIMessageChunk
-from langchain_core.agents import AgentFinish
-
-
-
-async def run_agent(agent, inputs: list):
-    if agent.agent_execution_mode == 'FuncCall':
-        exist_ids = set()
-        content_list = []
-        async for event in agent.astream_events(inputs, version="v2"):
-            kind = event["event"]
-            if kind == "on_chat_model_stream":
-                content = event["data"]["chunk"].content
-                if content:
-                    content_list.append(content)
-                    info("assistant", content)
-            elif kind == "on_chain_start":
-                data = event["data"]
-                if "input" in data:
-                    input_list = data["input"] if isinstance(data["input"], list) else [data["input"]]
-                    msg = input_list[-1]
-                    if isinstance(msg, AIMessage) and not isinstance(msg, AIMessageChunk):
-                        if "tool_calls" in msg.additional_kwargs:
-                            tool_calls = msg.additional_kwargs["tool_calls"]
-                            for t in tool_calls:
-                                if t["id"] in exist_ids:
-                                    continue
-                                exist_ids.add(t["id"])
-                                tool = t["function"]["name"]
-                                info("assistant", f"[调用工具:{tool}]")
-
-        return "".join(content_list)
-    else:
-        assert agent.agent_execution_mode == 'ReAct'
-        inputs_msg = {'input': inputs[-1].content,'chat_history': inputs[:-1]}
-        use_tools = []
-        async for event in agent.astream_events(inputs_msg, version="v2"):
-            kind = event["event"]
-            result = None
-            if kind == "on_chain_end":
-                if 'data' in event:
-                    if 'output' in event['data']:
-                        output = event['data']['output']
-                        if 'agent_outcome' in output and "input" in output:
-                            outcome = output['agent_outcome']
-                            if isinstance(outcome, AgentFinish):
-                                result = outcome.return_values['output']
-            elif kind == "on_tool_start":
-                use_tools.append(event['name'])
-                info("assistant", f"[调用工具:{use_tools}]")
-        return result
-
-
-if __name__ == "__main__":
-    from langchain_experimental.tools import PythonREPLTool
-    llm_file = r"C:\Users\aiqqq\AppData\Roaming\pycoze\JsonStorage\llm.json"
-    with open(llm_file, "r", encoding="utf-8") as f:
-        cfg = json.load(f)
-        chat = ChatOpenAI(api_key=cfg["apiKey"], base_url=cfg['baseURL'], model=cfg["model"], temperature=0)
-    python_tool = PythonREPLTool()
-    agent = Runnable(agent_execution_mode='FuncCall', # 'FuncCall' or 'ReAct'，大模型支持FuncCall的话就用FuncCall
-                                               tools=[python_tool],
-                                               llm=chat,
-                                               assistant_message="请以女友的口吻回答，输出不小于100字，可以随便说点其他的",)
-
-    inputs = [HumanMessage(content="计算根号7+根号88")]
-    print(asyncio.run(run_agent(agent, inputs)))

pycoze-0.1.20/pycoze/bot/agent/agent_types/__init__.py

@@ -1,10 +0,0 @@
-from .openai_func_call_agent import (
-    create_openai_func_call_agent_executor
-)
-from .react_agent import create_react_agent_executor
-
-
-__all__ = [
-    create_openai_func_call_agent_executor,
-    create_react_agent_executor
-]

pycoze-0.1.20/pycoze/bot/agent/agent_types/openai_func_call_agent.py

@@ -1,113 +0,0 @@
-# reference：https://github.com/maxtheman/opengpts/blob/d3425b1ba80aec48953a327ecd9a61b80efb0e69/backend/app/agent_types/openai_agent.py
-import json
-
-from langchain.tools import BaseTool
-from langchain_core.utils.function_calling import convert_to_openai_tool
-from langchain_core.language_models.base import LanguageModelLike
-from langchain_core.messages import  SystemMessage, ToolMessage
-from langgraph.graph import END
-from langgraph.graph.message import MessageGraph
-from langgraph.prebuilt import ToolExecutor, ToolInvocation
-from typing import Any
-
-
-def create_openai_func_call_agent_executor(tools: list[BaseTool], llm: LanguageModelLike,
-                                        system_message: str, **kwargs):
-
-    async def _get_messages(messages):
-        msgs = []
-        for m in messages:
-            if isinstance(m, ToolMessage):
-                _dict = m.dict()
-                _dict['content'] = str(_dict['content'])
-                m_c = ToolMessage(**_dict)
-                msgs.append(m_c)
-            else:
-                msgs.append(m)
-
-        return [SystemMessage(content=system_message)] + msgs
-
-    if tools:
-        llm_with_tools = llm.bind(tools=[convert_to_openai_tool(t) for t in tools])
-    else:
-        llm_with_tools = llm
-    agent = _get_messages | llm_with_tools
-    tool_executor = ToolExecutor(tools)
-
-    # Define the function that determines whether to continue or not
-    def should_continue(messages):
-        # If there is no FuncCall, then we finish
-        last_message = messages[-1]
-        if not last_message.tool_calls:
-            return "end"
-        # Otherwise if there is, we continue
-        else:
-            return "continue"
-
-    # Define the function to execute tools
-    async def call_tool(messages):
-        actions: list[ToolInvocation] = []
-        # Based on the continue condition
-        # we know the last message involves a FuncCall
-        last_message = messages[-1]
-        for tool_call in last_message.additional_kwargs['tool_calls']:
-            function = tool_call['function']
-            function_name = function['name']
-            _tool_input = json.loads(function['arguments'] or '{}')
-            # We construct an ToolInvocation from the function_call
-            actions.append(ToolInvocation(
-                tool=function_name,
-                tool_input=_tool_input,
-            ))
-        # We call the tool_executor and get back a response
-        responses = await tool_executor.abatch(actions, **kwargs)
-        # We use the response to create a ToolMessage
-        tool_messages = [
-            ToolMessage(
-                tool_call_id=tool_call['id'],
-                content=response,
-                additional_kwargs={'name': tool_call['function']['name']},
-            )
-            for tool_call, response in zip(last_message.additional_kwargs['tool_calls'], responses)
-        ]
-        return tool_messages
-
-    workflow = MessageGraph()
-
-    # Define the two nodes we will cycle between
-    workflow.add_node('agent', agent)
-    workflow.add_node('action', call_tool)
-
-    # Set the entrypoint as `agent`
-    # This means that this node is the first one called
-    workflow.set_entry_point('agent')
-
-    # We now add a conditional edge
-    workflow.add_conditional_edges(
-        # First, we define the start node. We use `agent`.
-        # This means these are the edges taken after the `agent` node is called.
-        'agent',
-        # Next, we pass in the function that will determine which node is called next.
-        should_continue,
-        # Finally we pass in a mapping.
-        # The keys are strings, and the values are other nodes.
-        # END is a special node marking that the graph should finish.
-        # What will happen is we will call `should_continue`, and then the output of that
-        # will be matched against the keys in this mapping.
-        # Based on which one it matches, that node will then be called.
-        {
-            # If `tools`, then we call the tool node.
-            'continue': 'action',
-            # Otherwise we finish.
-            'end': END,
-        },
-    )
-
-    # We now add a normal edge from `tools` to `agent`.
-    # This means that after `tools` is called, `agent` node is called next.
-    workflow.add_edge('action', 'agent')
-
-    # Finally, we compile it!
-    # This compiles it into a LangChain Runnable,
-    # meaning you can use it as you would any other runnable
-    return workflow.compile()

pycoze-0.1.20/pycoze/bot/agent/agent_types/react_agent.py

@@ -1,170 +0,0 @@
-# https://github.com/langchain-ai/langgraph/blob/ea071935fef240d631305df12b6d83e9c363cef3/libs/langgraph/langgraph/prebuilt/agent_executor.py
-import operator
-from typing import Annotated, Sequence, TypedDict, Union
-from langchain.tools import BaseTool
-from langchain_core.agents import AgentAction, AgentFinish
-from langchain_core.messages import BaseMessage
-from langchain_core.language_models import LanguageModelLike
-from langgraph.graph import END, StateGraph
-from langgraph.graph.state import CompiledStateGraph
-from langgraph.prebuilt.tool_executor import ToolExecutor
-from langgraph.utils.runnable import RunnableCallable
-from langchain.agents import create_structured_chat_agent
-from .react_prompt import react_agent_prompt
-
-
-def create_react_agent_executor(
-    tools: list[BaseTool],
-    llm: LanguageModelLike,
-    system_message: str,
-    **kwargs # ignore
-):
-    prompt = react_agent_prompt.partial(assistant_message=system_message)
-    agent = create_structured_chat_agent(llm, tools, prompt)
-    agent_executer = create_agent_executor(agent, tools)
-    return agent_executer
-
-
-def _get_agent_state(input_schema=None):
-    if input_schema is None:
-
-        class AgentState(TypedDict):
-            # The input string
-            input: str
-            # The list of previous messages in the conversation
-            chat_history: Sequence[BaseMessage]
-            # The outcome of a given call to the agent
-            # Needs `None` as a valid type, since this is what this will start as
-            agent_outcome: Union[AgentAction, AgentFinish, None]
-            # List of actions and corresponding observations
-            # Here we annotate this with `operator.add` to indicate that operations to
-            # this state should be ADDED to the existing values (not overwrite it)
-            intermediate_steps: Annotated[list[tuple[AgentAction, str]], operator.add]
-
-    else:
-
-        class AgentState(input_schema):
-            # The outcome of a given call to the agent
-            # Needs `None` as a valid type, since this is what this will start as
-            agent_outcome: Union[AgentAction, AgentFinish, None]
-            # List of actions and corresponding observations
-            # Here we annotate this with `operator.add` to indicate that operations to
-            # this state should be ADDED to the existing values (not overwrite it)
-            intermediate_steps: Annotated[list[tuple[AgentAction, str]], operator.add]
-
-    return AgentState
-
-
-def create_agent_executor(
-    agent_runnable, tools, input_schema=None
-) -> CompiledStateGraph:
-    """This is a helper function for creating a graph that works with LangChain Agents.
-
-    Args:
-        agent_runnable (RunnableLike): The agent runnable.
-        tools (list): A list of tools to be used by the agent.
-        input_schema (dict, optional): The input schema for the agent. Defaults to None.
-
-    Returns:
-        The `CompiledStateGraph` object.
-    """
-
-    if isinstance(tools, ToolExecutor):
-        tool_executor = tools
-    else:
-        tool_executor = ToolExecutor(tools)
-
-    state = _get_agent_state(input_schema)
-
-    # Define logic that will be used to determine which conditional edge to go down
-
-    def should_continue(data):
-        # If the agent outcome is an AgentFinish, then we return `exit` string
-        # This will be used when setting up the graph to define the flow
-        if isinstance(data["agent_outcome"], AgentFinish):
-            return "end"
-        # Otherwise, an AgentAction is returned
-        # Here we return `continue` string
-        # This will be used when setting up the graph to define the flow
-        else:
-            return "continue"
-
-    def run_agent(data, config):
-        agent_outcome = agent_runnable.invoke(data, config)
-        return {"agent_outcome": agent_outcome}
-
-    async def arun_agent(data, config):
-        agent_outcome = await agent_runnable.ainvoke(data, config)
-        return {"agent_outcome": agent_outcome}
-
-    # Define the function to execute tools
-    def execute_tools(data, config):
-        # Get the most recent agent_outcome - this is the key added in the `agent` above
-        agent_action = data["agent_outcome"]
-        if not isinstance(agent_action, list):
-            agent_action = [agent_action]
-        output = tool_executor.batch(agent_action, config, return_exceptions=True)
-        return {
-            "intermediate_steps": [
-                (action, str(out)) for action, out in zip(agent_action, output)
-            ]
-        }
-
-    async def aexecute_tools(data, config):
-        # Get the most recent agent_outcome - this is the key added in the `agent` above
-        agent_action = data["agent_outcome"]
-        if not isinstance(agent_action, list):
-            agent_action = [agent_action]
-        output = await tool_executor.abatch(
-            agent_action, config, return_exceptions=True
-        )
-        return {
-            "intermediate_steps": [
-                (action, str(out)) for action, out in zip(agent_action, output)
-            ]
-        }
-
-    # Define a new graph
-    workflow = StateGraph(state)
-
-    # Define the two nodes we will cycle between
-    workflow.add_node("agent", RunnableCallable(run_agent, arun_agent))
-    workflow.add_node("tools", RunnableCallable(execute_tools, aexecute_tools))
-
-    # Set the entrypoint as `agent`
-    # This means that this node is the first one called
-    workflow.set_entry_point("agent")
-
-    # We now add a conditional edge
-    workflow.add_conditional_edges(
-        # First, we define the start node. We use `agent`.
-        # This means these are the edges taken after the `agent` node is called.
-        "agent",
-        # Next, we pass in the function that will determine which node is called next.
-        should_continue,
-        # Finally we pass in a mapping.
-        # The keys are strings, and the values are other nodes.
-        # END is a special node marking that the graph should finish.
-        # What will happen is we will call `should_continue`, and then the output of that
-        # will be matched against the keys in this mapping.
-        # Based on which one it matches, that node will then be called.
-        {
-            # If `tools`, then we call the tool node.
-            "continue": "tools",
-            # Otherwise we finish.
-            "end": END,
-        },
-    )
-
-    # We now add a normal edge from `tools` to `agent`.
-    # This means that after `tools` is called, `agent` node is called next.
-    workflow.add_edge("tools", "agent")
-
-    # Finally, we compile it!
-    # This compiles it into a LangChain Runnable,
-    # meaning you can use it as you would any other runnable
-    return workflow.compile()
-
-
-if __name__ == "__main__":
-    pass

pycoze-0.1.20/pycoze/bot/agent/agent_types/react_prompt.py

@@ -1,67 +0,0 @@
-from typing import List, Union
-from langchain_core.prompts.chat import (
-    ChatPromptTemplate,
-    HumanMessagePromptTemplate,
-    SystemMessagePromptTemplate,
-    MessagesPlaceholder
-)
-from langchain_core.messages import FunctionMessage, SystemMessage, ToolMessage, AIMessage, HumanMessage, ChatMessage
-
-
-system_temp = """
-{assistant_message}
-
-Respond to the human as helpfully and accurately as possible. You have access to the following tools:
-
-{tools}
-
-Use a json blob to specify a tool by providing an action key (tool name) and an action_input key (tool input).
-
-Valid "action" values: "Final Answer" or {tool_names}
-
-Provide only ONE action per $JSON_BLOB, as shown:
-
-```
-{{{{
-  "action": $TOOL_NAME,
-  "action_input": $INPUT
-}}}}
-```
-
-Follow this format:
-
-Question: input question to answer
-Thought: consider previous and subsequent steps
-Action:
-```
-$JSON_BLOB
-```
-Observation: action result
-... (repeat Thought/Action/Observation N times)
-Thought: I know what to respond
-Action:
-```
-{{{{
-  "action": "Final Answer",
-  "action_input": "Final response to human"
-}}}}
-
-Begin! Reminder to ALWAYS respond with a valid json blob of a single action. Use tools if necessary. Respond directly if appropriate. Format is Action:```$JSON_BLOB```then Observation
-"""
-
-human_temp = """Question: {input}
-
-Thought: {agent_scratchpad}
-(reminder to respond in a JSON blob no matter what)"""
-
-
-react_agent_prompt = ChatPromptTemplate(
-    input_variables=['agent_scratchpad', 'input', 'tool_names', 'tools', 'assistant_message'], 
-    optional_variables=['chat_history'], 
-    input_types={'chat_history': List[Union[AIMessage, HumanMessage, ChatMessage, SystemMessage, FunctionMessage, ToolMessage]]}, 
-    messages=[
-        SystemMessagePromptTemplate.from_template(system_temp),
-        MessagesPlaceholder(variable_name='chat_history', optional=True), 
-        HumanMessagePromptTemplate.from_template(human_temp)
-    ]
-)

pycoze-0.1.20/pycoze/bot/agent/assistant.py

@@ -1,35 +0,0 @@
-from typing import Sequence
-from langchain.tools import BaseTool
-from langchain_core.language_models.base import LanguageModelLike
-from langchain_core.runnables import RunnableBinding
-from .agent_types import create_openai_func_call_agent_executor, create_react_agent_executor
-
-
-class Runnable(RunnableBinding):
-    agent_execution_mode: str
-    tools: Sequence[BaseTool]
-    llm: LanguageModelLike
-    assistant_message: str
-
-    def __init__(
-        self,
-        *,
-        agent_execution_mode: str,
-        tools: Sequence[BaseTool],
-        llm: LanguageModelLike,
-        assistant_message: str,
-    ) -> None:
-        
-        if agent_execution_mode == "FuncCall":
-            agent_executor_object = create_openai_func_call_agent_executor
-        else:
-            agent_executor_object = create_react_agent_executor
-        agent_executor = agent_executor_object(tools, llm, assistant_message)
-        agent_executor = agent_executor.with_config({"recursion_limit": 50})
-        super().__init__(
-            tools=tools,
-            llm=llm,
-            agent_execution_mode=agent_execution_mode,
-            assistant_message=assistant_message,
-            bound=agent_executor, return_intermediate_steps=True
-        )

pycoze-0.1.20/pycoze/bot/agent/chat.py

@@ -1,28 +0,0 @@
-import json
-from langchain_core.messages import HumanMessage, AIMessage
-
-
-INPUT_MESSAGE = "INPUT_MESSAGE=>"
-_OUTPUT_MESSAGE = "OUTPUT_MESSAGE=>"
-_INFOMATION_MESSAGE = "INFOMATION_MESSAGE=>"
-_LOG = "LOG=>"
-
-
-
-def log(content, *args, end='\n', **kwargs):
-    print(_LOG + content, *args, end=end, **kwargs)
-
-
-def output(role, content, history):
-    print(_OUTPUT_MESSAGE + json.dumps({"role": role, "content": content}))
-    if role == "assistant":
-        history.append(AIMessage(content=content))
-        
-    elif role == "user":
-        history.append(HumanMessage(content=content))
-    else:
-        raise ValueError("Invalid role")
-    return history
-
-def info(role, content):
-     print(_INFOMATION_MESSAGE + json.dumps({"role": role, "content": content}))

pycoze-0.1.20/pycoze/bot/base.py

@@ -1,81 +0,0 @@
-import sys
-import os
-import argparse
-import importlib
-from langchain.agents import tool as _tool
-import types
-import langchain_core
-
-def wrapped_tool(tool, module_path):
-    old_tool_fun = tool.func
-    def _wrapped_tool(*args, **kwargs):
-        print(f"调用了{tool.name}")
-        old_path = os.getcwd()
-        try:
-            sys.path.insert(0, module_path)  # 插入到第一个位置
-            os.chdir(module_path)
-            result = old_tool_fun(*args, **kwargs)
-        finally:
-            sys.path.remove(module_path)
-            os.chdir(old_path)
-        print(f"{tool.name}调用完毕,结果为:", result)
-        return result
-    return _wrapped_tool
-
-
-def import_tools(tool_id):
-    tool_path = "../../tool"
-    old_path = os.getcwd()
-    module_path = os.path.join(tool_path, tool_id)
-    module_path = os.path.normpath(os.path.abspath(module_path))
-
-    if not os.path.exists(module_path):
-        print(f"Tool {tool_id} not found")
-        return []
-
-    # 保存当前的 sys.modules 状态
-    original_modules = sys.modules.copy()
-
-    try:
-        sys.path.insert(0, module_path)  # 插入到第一个位置
-        os.chdir(module_path)
-        module = importlib.import_module("tool")
-        export_tools = getattr(module, "export_tools")
-        temp_list = []
-        for tool in export_tools:
-            assert isinstance(tool, langchain_core.tools.StructuredTool) or isinstance(tool, types.FunctionType), f"Tool is not a StructuredTool or function: {tool}"
-            if isinstance(tool, types.FunctionType) and not isinstance(tool, langchain_core.tools.StructuredTool):
-                temp_list.append(_tool(tool))
-        export_tools = temp_list
-
-    except Exception as e:
-        print(f"Error loading tool {tool_id}: {e}")
-        sys.path.remove(module_path)
-        os.chdir(old_path)
-        return []
-
-    # 卸载模块并恢复 sys.modules 状态
-    importlib.invalidate_caches()
-    for key in list(sys.modules.keys()):
-        if key not in original_modules:
-            del sys.modules[key]
-
-    sys.path.remove(module_path)
-    os.chdir(old_path)
-
-    for tool in export_tools:
-        tool.func = wrapped_tool(tool, module_path)
-
-    return export_tools
-
-
-def read_arg(param: str, is_path=False):
-    parser = argparse.ArgumentParser()
-    parser.add_argument(param, nargs='?', help=f'Parameter {param}')
-    args = parser.parse_args()
-    value = getattr(args, param.lstrip('-'))
-    # 如果是路径并且有引号，去掉引号
-    if is_path and value and value.startswith('"') and value.endswith('"'):
-        value = value[1:-1]
-
-    return value

pycoze-0.1.20/pycoze/bot/bot.py

@@ -1,54 +0,0 @@
-import json
-from langchain_openai import ChatOpenAI
-from .base import import_tools
-from .agent import run_agent, Runnable, INPUT_MESSAGE, output
-import asyncio
-from langchain_core.messages import HumanMessage
-from pycoze import utils
-
-
-params = utils.arg.read_params()
-llm_file = params["appPath"] + "/JsonStorage/llm.json"
-
-def load_role_setting(bot_setting_file:str):
-    with open(bot_setting_file, "r", encoding="utf-8") as f:
-        return json.load(f)
-
-def load_tools(bot_setting_file:str):
-    with open(bot_setting_file, "r", encoding="utf-8") as f:
-        role_setting = json.load(f)
-
-    tools = []
-    for tool_id in role_setting["tools"]:
-        tools.extend(import_tools(tool_id))
-    return tools
-
-
-
-
-def chat(bot_setting_file:str):
-    history = []
-
-    while True:
-        message = input()
-        role_setting = load_role_setting(bot_setting_file)
-        tools = load_tools(bot_setting_file)
-        if not message.startswith(INPUT_MESSAGE):
-            raise ValueError("Invalid message")
-        message = json.loads(message[len(INPUT_MESSAGE):])["content"]
-        print("user:", message)
-
-        with open(llm_file, "r", encoding="utf-8") as f:
-            cfg = json.load(f)
-            chat = ChatOpenAI(api_key=cfg["apiKey"], base_url=cfg['baseURL'], model=cfg["model"], temperature=role_setting["temperature"])
-
-
-        agent = Runnable(agent_execution_mode='FuncCall', # 'FuncCall' or 'ReAct'，大模型支持FuncCall的话就用FuncCall
-                                                tools=tools,
-                                                llm=chat,
-                                                assistant_message=role_setting["prompt"],)
-
-        history += [HumanMessage(content=message)]
-        result = asyncio.run(run_agent(agent, history))
-        output("assistant", result, history)
-

pycoze-0.1.20/pycoze/gpu/__init__.py

@@ -1 +0,0 @@
-from .gpu_reserve import reserve_gpu_retry, release_gpu, reserve_gpu_retry

pycoze-0.1.20/pycoze/gpu/gpu_reserve.py

@@ -1,167 +0,0 @@
-import subprocess
-import sqlite3
-import atexit
-import time
-import os
-import psutil
-
-try:
-    from pycoze.utils import utils
-
-    # 定义数据库连接和初始化
-    params = utils.arg.read_params()
-    if params:
-        DATABASE_PATH = params["appPath"] + "/gpu_usage.db"
-    else:
-        raise Exception("No params")
-except:
-    DATABASE_DIR = os.path.expanduser("~/pycoze")
-    os.makedirs(DATABASE_DIR, exist_ok=True)
-    DATABASE_PATH = os.path.join(DATABASE_DIR, "gpu_usage.db")
-TABLE_NAME = "gpu_usage"
-
-
-def initialize_db():
-    conn = sqlite3.connect(DATABASE_PATH)
-    cursor = conn.cursor()
-    cursor.execute(
-        f"""
-        CREATE TABLE IF NOT EXISTS {TABLE_NAME} (
-            id INTEGER PRIMARY KEY,
-            process_id TEXT NOT NULL,
-            reserved_gb REAL NOT NULL
-        )
-    """
-    )
-    conn.commit()
-    conn.close()
-
-
-# 检测GPU资源
-def get_gpu_resources():
-    try:
-        # 使用nvidia-smi命令获取GPU信息
-        result = subprocess.run(
-            ["nvidia-smi", "--query-gpu=memory.free", "--format=csv,noheader,nounits"],
-            stdout=subprocess.PIPE,
-            text=True,
-        )
-        free_memory = result.stdout.strip().split("\n")
-        total_free_memory = sum(float(mem) for mem in free_memory)
-
-        # 获取正在使用GPU的进程信息
-        process_result = subprocess.run(
-            [
-                "nvidia-smi",
-                "--query-compute-apps=pid,process_name,used_memory",
-                "--format=csv,noheader,nounits",
-            ],
-            stdout=subprocess.PIPE,
-            text=True,
-        )
-        process_info = process_result.stdout.strip().split("\n")
-
-        # 过滤掉进程名中包含"python"的进程
-        python_memory_usage = 0.0
-        for process in process_info:
-            pid, process_name, used_memory = process.split(", ")
-            if "python" in process_name.lower():
-                python_memory_usage += float(used_memory)
-
-        # 计算排除python进程后的总空闲内存
-        total_free_memory -= python_memory_usage
-        return round(total_free_memory / 1024, 2)
-    except Exception as e:
-        print(f"Error getting GPU resources: {e}")
-        return 0.0
-
-
-# 预留GPU资源
-def reserve_gpu(gb):
-    process_id = str(os.getpid())
-    with sqlite3.connect(DATABASE_PATH) as conn:
-        cursor = conn.cursor()
-        cursor.execute(f"SELECT SUM(reserved_gb) FROM {TABLE_NAME}")
-        total_reserved = cursor.fetchone()[0]
-        if total_reserved is None:
-            total_reserved = 0.0
-        available_gb = get_gpu_resources() - total_reserved
-        if available_gb >= gb:
-            cursor.execute(
-                f"INSERT INTO {TABLE_NAME} (process_id, reserved_gb) VALUES (?, ?)",
-                (process_id, gb),
-            )
-            conn.commit()
-            print(f"预留成功，剩余GPU大小: {available_gb - gb} GB")
-            return True
-        else:
-            print(f"预留失败，剩余GPU大小: {available_gb} GB")
-            return False
-
-
-def reserve_gpu_retry(gb, retry=10000):
-    for i in range(retry):
-        time.sleep(1)
-        if reserve_gpu(gb):
-            if i % 10 == 0 or i < 10:
-                print(f"重试第{i}次")
-            return True
-    return False
-
-
-# 释放GPU资源
-def release_gpu():
-    process_id = str(os.getpid())
-    with sqlite3.connect(DATABASE_PATH) as conn:
-        cursor = conn.cursor()
-        cursor.execute(f"DELETE FROM {TABLE_NAME} WHERE process_id = ?", (process_id,))
-        conn.commit()
-        # 计算释放后的剩余GPU大小
-        cursor.execute(f"SELECT SUM(reserved_gb) FROM {TABLE_NAME}")
-        total_reserved = cursor.fetchone()[0]
-        if total_reserved is None:
-            total_reserved = 0.0
-        available_gb = get_gpu_resources() - total_reserved
-        print(f"释放成功，剩余GPU大小: {available_gb} GB")
-
-
-# 注册退出时的清理函数
-def cleanup():
-    release_gpu()
-    print("程序退出，GPU资源已释放")
-
-
-def initialize_and_check():
-    initialize_db()
-    with sqlite3.connect(DATABASE_PATH) as conn:
-        cursor = conn.cursor()
-        cursor.execute(f"SELECT process_id, reserved_gb FROM {TABLE_NAME}")
-        rows = cursor.fetchall()
-        for row in rows:
-            process_id, reserved_gb = row
-            try:
-                # 检查进程是否存在
-                psutil.Process(int(process_id))
-            except psutil.NoSuchProcess:
-                # 进程不存在，删除对应的记录
-                cursor.execute(
-                    f"DELETE FROM {TABLE_NAME} WHERE process_id = ?", (process_id,)
-                )
-                print(f"进程 {process_id} 不存在，已删除对应的预留记录")
-        conn.commit()
-
-
-# 在模块加载时执行初始化检查
-initialize_and_check()
-
-# 注册清理函数
-atexit.register(cleanup)
-
-if __name__ == "__main__":
-    if reserve_gpu_retry(10):
-        print("GPU资源预留成功")
-        time.sleep(100)
-        release_gpu()
-        print("GPU资源释放成功")
-    else:
-        print("GPU资源不足，无法预留")

pycoze-0.1.20/pycoze/ui/__init__.py

@@ -1 +0,0 @@
-from .ui_def import get_ui, get_ui_text, label, number, text, textarea, password, color, checkbox, single_select, multi_select, file, folder, folder_tree, image, audio, video, seed

pycoze-0.1.20/pycoze/ui/base.py

@@ -1,50 +0,0 @@
-import json
-from pycoze import utils
-import json
-import inspect
-
-
-params_file = utils.read_arg('params_file', True)
-params = None
-try:
-    with open(params_file, 'r', encoding='utf-8') as f:
-        params = json.load(f)
-except Exception as e:
-    print(e)
-
-def get_ui():
-    if params is None:
-        return {}
-    stack = inspect.stack()
-    stack_files = list(reversed([s.filename.replace('\\', '/') for s in stack]))
-    match_item = None
-    for f in stack_files:
-        for v in params["uiRecords"]:
-            if v["uiFile"] == f:
-                match_item = v
-                break
-        if match_item:
-            break
-
-    if not match_item:
-        raise Exception("uiRecords not found for file")
-
-    by = match_item["by"]
-
-    for i in range(10):
-        try:
-            if by == 'file':
-                json_file = match_item["Jsonfile"]
-                with open(json_file, "r", encoding='utf-8') as f:
-                    return json.load(f)
-            else:
-                assert by == 'node'
-                workflow_file = match_item["workflowFile"]
-                node_id = match_item["nodeId"]
-                with open(workflow_file, "r", encoding='utf-8') as f:
-                    cells = json.load(f)["graph"]["cells"]
-                    node = [cell for cell in cells if cell["id"] == node_id][0]
-                    return json.loads(node["data"]["ui"])
-        except Exception as e:
-            if i == 9:
-                raise e

pycoze-0.1.20/pycoze/ui/color.py

@@ -1,34 +0,0 @@
-from enum import Enum
-
-class ColorFormat(Enum):
-    HEX = "hex"
-    RGB = "rgb"
-    HSL = "hsl"
-
-
-def hex_to_rgb(hex_color):
-    # Convert HEX to RGB
-    hex_color = hex_color.lstrip('#')
-    return tuple(int(hex_color[i:i+2], 16) for i in (0, 2, 4))
-
-
-def rgb_to_hsl(rgb):
-    r, g, b = rgb[0] / 255.0, rgb[1] / 255.0, rgb[2] / 255.0
-    max_val = max(r, g, b)
-    min_val = min(r, g, b)
-    lightness = (max_val + min_val) / 2  # 直接用l容易混淆
-
-    if max_val == min_val:
-        h, s = 0, 0
-    else:
-        d = max_val - min_val
-        s = d / (2 - max_val - min_val) if lightness > 0.5 else d / (max_val + min_val)
-        if max_val == r:
-            h = (g - b) / d + (6 if g < b else 0)
-        elif max_val == g:
-            h = (b - r) / d + 2
-        else:
-            h = (r - g) / d + 4
-        h /= 6
-
-    return h, s, lightness

pycoze-0.1.20/pycoze/ui/typ.py

@@ -1,56 +0,0 @@
-def to_bool(v):
-    if v in ["True", "true", True]:
-        return True
-    elif v in ["False", "false", False]:
-        return False
-    else:
-        return None
-
-
-def toType(val, typ):
-    val_type = type(val)
-    if typ in [str, float]:
-        return typ(val) if val_type != list else [typ(item) for item in val]
-    elif typ == int:
-        try:
-            return typ(val) if val_type != list else [typ(item) for item in val]
-        except:
-            return float(val) if val_type != list else [float(item) for item in val]
-    elif typ == bool:
-        return to_bool(val) if val_type != list else [to_bool(item) for item in val]
-
-
-def useDefaultType(val, default):
-    val_type = type(val)
-    default_type = type(default)
-
-    # 根据 default 的类型进行转换
-    if default_type in [str, int, float, bool]:
-        try:
-            val = toType(val, default_type)
-            if val_type == list:
-                try:
-                    val = val[0]
-                except:
-                    return default
-        except:
-            return None
-    elif default_type == list:
-        try:
-            if len(default) > 0:
-                if val_type != list:
-                    val = [useDefaultType(val, default[0])]
-                # 判断 default 列表中元素的类型，假设所有元素类型相同
-                if len(val) > 0:
-                    element_type = type(default[0])
-                    if type(val[0]) is element_type:
-                        val = toType(val, element_type)
-                else:
-                    val = []
-            else:
-                if val_type != list:
-                    val = [val]
-        except:
-            return None
-    return val
-

pycoze-0.1.20/pycoze/ui/ui_def.py

@@ -1,167 +0,0 @@
-from .base import get_ui
-from .typ import useDefaultType
-from typing import Union, List
-from .color import hex_to_rgb, rgb_to_hsl, ColorFormat
-import sys
-
-
-def useDefault(name, default):
-    ui_data = get_ui()
-    if name not in ui_data:
-        return default
-    return useDefaultType(ui_data[name], default)
-
-
-def get_ui_text():
-    ui = get_ui()
-    output = ""
-    for key, value in ui.items():
-        output += f"{key}: {value}\n"
-    return output
-
-
-def label(name, tip="", hide_if="", style="", cls=""):
-    pass
-
-
-def number(
-    name,
-    default,
-    min=-sys.maxsize - 1,
-    max=sys.maxsize,
-    step=1,
-    tip="",
-    hide_if="",
-    style="",
-    cls="",
-) -> Union[int, float]:  # 注意Python3.9不兼容int|float
-    return useDefault(name, default)
-
-
-def text(name, default, tip="", hide_if="", style="", cls="") -> str:
-    return useDefault(name, default)
-
-
-def textarea(name, default, tip="", hide_if="", style="", cls="") -> str:
-    return useDefault(name, default)
-
-
-def password(name, default, tip="", hide_if="", style="", cls="") -> str:
-    return useDefault(name, default)
-
-
-def color(
-    name,
-    default,
-    color_format: ColorFormat = "hex",
-    tip="",
-    hide_if="",
-    style="",
-    cls="",
-) -> str:
-    rgbhex = useDefault(name, default)
-    if color_format == "hex":
-        return rgbhex
-    elif color_format == "rgb":
-        return hex_to_rgb(rgbhex)
-    elif color_format == "hsl":
-        return rgb_to_hsl(hex_to_rgb(rgbhex))
-    return rgbhex
-
-
-def checkbox(name, default, tip="", hide_if="", style="", cls="") -> bool:
-    return useDefault(name, default)
-
-
-def single_select(
-    name,
-    default: Union[str, int, float, bool],
-    options,
-    tip="",
-    hide_if="",
-    style="",
-    cls="",
-):
-    return useDefault(name, default)
-
-
-def multi_select(
-    name,
-    default: Union[List[str], List[int], List[float], List[bool]],
-    options,
-    tip="",
-    hide_if="",
-    style="",
-    cls="",
-):
-    return useDefault(name, default)
-
-
-def single_file_select(name, default: str, tip="", hide_if="", style="", cls="") -> str:
-    return useDefault(name, default)
-
-
-def multi_file_select(
-    name, default: List[str], tip="", hide_if="", style="", cls=""
-) -> List[str]:
-    return useDefault(name, default)
-
-
-def single_folder_select(
-    name, default: str, tip="", hide_if="", style="", cls=""
-) -> str:
-    return useDefault(name, default)
-
-
-def multi_folder_select(
-    name, default: List[str], tip="", hide_if="", style="", cls=""
-) -> List[str]:
-    return useDefault(name, default)
-
-
-def folder_tree(
-    name, root="", default: List[str] = None, tip="", hide_if="", style="", cls=""
-) -> dict:
-    if default is None:
-        default = []
-    return useDefault(name, default)
-
-
-def single_image_select(
-    name, default: str, tip="", hide_if="", style="", cls=""
-) -> str:
-    return useDefault(name, default)
-
-
-def multi_image_select(
-    name, default: List[str], tip="", hide_if="", style="", cls=""
-) -> List[str]:
-    return useDefault(name, default)
-
-
-def single_audio_select(
-    name, default: str, tip="", hide_if="", style="", cls=""
-) -> str:
-    return useDefault(name, default)
-
-
-def multi_audio_select(
-    name, default: List[str], tip="", hide_if="", style="", cls=""
-) -> List[str]:
-    return useDefault(name, default)
-
-
-def single_video_select(
-    name, default: str, tip="", hide_if="", style="", cls=""
-) -> str:
-    return useDefault(name, default)
-
-
-def multi_video_select(
-    name, default: List[str], tip="", hide_if="", style="", cls=""
-) -> List[str]:
-    return useDefault(name, default)
-
-
-def seed(name, default=0, tip="", hide_if="", style="", cls="") -> int:
-    return useDefault(name, default)

pycoze-0.1.20/pycoze/utils/__init__.py

@@ -1 +0,0 @@
-from .arg import read_arg, read_params

pycoze-0.1.20/pycoze/utils/arg.py

@@ -1,25 +0,0 @@
-import argparse
-import sys
-import json
-
-def read_arg(param, is_path=False):
-    args = sys.argv[1:]
-    parser = argparse.ArgumentParser()
-    parser.add_argument(param, nargs='?', help=f'Parameter {param}')
-    args = parser.parse_known_args(args)[0]
-    value = getattr(args, param.lstrip('-'))
-    # 如果是路径并且有引号，去掉引号
-    if is_path and value and value.startswith('"') and value.endswith('"'):
-        value = value[1:-1]
-
-    return value
-
-def read_params():
-  params_file = read_arg('params_file', True)
-  params = None
-  try:
-      with open(params_file, 'r', encoding='utf-8') as f:
-          params = json.load(f)
-  except Exception as e:
-      print(e)
-  return params

pycoze-0.1.20/pycoze.egg-info/SOURCES.txt

@@ -1,29 +0,0 @@
-LICENSE
-README.md
-setup.py
-pycoze/__init__.py
-pycoze/module.py
-pycoze.egg-info/PKG-INFO
-pycoze.egg-info/SOURCES.txt
-pycoze.egg-info/dependency_links.txt
-pycoze.egg-info/top_level.txt
-pycoze/bot/__init__.py
-pycoze/bot/base.py
-pycoze/bot/bot.py
-pycoze/bot/agent/__init__.py
-pycoze/bot/agent/agent.py
-pycoze/bot/agent/assistant.py
-pycoze/bot/agent/chat.py
-pycoze/bot/agent/agent_types/__init__.py
-pycoze/bot/agent/agent_types/openai_func_call_agent.py
-pycoze/bot/agent/agent_types/react_agent.py
-pycoze/bot/agent/agent_types/react_prompt.py
-pycoze/gpu/__init__.py
-pycoze/gpu/gpu_reserve.py
-pycoze/ui/__init__.py
-pycoze/ui/base.py
-pycoze/ui/color.py
-pycoze/ui/typ.py
-pycoze/ui/ui_def.py
-pycoze/utils/__init__.py
-pycoze/utils/arg.py

pycoze-0.1.20/pycoze.egg-info/top_level.txt

@@ -1 +0,0 @@
-pycoze