hjxdl 0.3.56__py3-none-any.whl → 0.3.58__py3-none-any.whl

hdl/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.3.56'
-__version_tuple__ = version_tuple = (0, 3, 56)
+__version__ = version = '0.3.58'
+__version_tuple__ = version_tuple = (0, 3, 58)
 
-__commit_id__ = commit_id = 'g5d6407784'
+__commit_id__ = commit_id = 'ge579fcb03'

hdl/utils/llm/chat.py

@@ -302,71 +302,6 @@ class OpenAI_M:
                 continue
 
     def get_resp(
-        self,
-        prompt: str,
-        client_id: str = None,
-        sys_info: str = None,
-        assis_info: str = None,
-        images: list = None,
-        image_keys: tuple = ("image_url", "url"),
-        stop: list[str] | None = ["USER:", "ASSISTANT:"],
-        model: str = None,
-        stream: bool = True,
-        **kwargs: t.Any,
-    ):
-        """Prepare and send a request to the model, and return the model's response."""
-        if not model:
-            model = self.client_conf[client_id]["model"]
-
-        # === 1️⃣ 准备输入 ===
-        content = [{"type": "text", "text": prompt}]
-        if isinstance(image_keys, str):
-            image_keys = (image_keys,) * 3
-        elif len(image_keys) == 2:
-            image_keys = (image_keys[0],) + tuple(image_keys)
-        elif len(image_keys) == 1:
-            image_keys = (image_keys[0],) * 3
-
-        if images:
-            if isinstance(images, str):
-                images = [images]
-            for img in images:
-                content.append({
-                    "type": image_keys[0],
-                    image_keys[1]: {image_keys[2]: img}
-                })
-        else:
-            content = prompt
-
-        # === 2️⃣ 构造 messages（兼容旧逻辑） ===
-        messages = []
-        if sys_info:
-            messages.append({"role": "system", "content": sys_info})
-        messages.append({"role": "user", "content": content})
-        if assis_info:
-            messages.append({"role": "assistant", "content": assis_info})
-
-        # === 3️⃣ 改成 responses.create ===
-        client = self.client_conf[client_id]["client"]
-
-        if stream:
-            response = client.responses.create(
-                model=model,
-                input=messages,       # 注意：新版 responses 接口直接用 "input"
-                stream=True,
-                **kwargs
-            )
-        else:
-            response = client.responses.create(
-                model=model,
-                input=messages,
-                stream=False,
-                **kwargs
-            )
-
-        return response
-
-    def get_resp_legacy(
         self,
         prompt: str,
         client_id: str = None,

hdl/utils/llm/llm_wrapper.py

@@ -3,6 +3,7 @@ import typing as t
 
 from openai import OpenAI
 
+
 class OpenAIWrapper(object):
     def __init__(
         self,
@@ -14,6 +15,29 @@ class OpenAIWrapper(object):
     ):
         """
         Initializes the client configuration for the class.
+
+        Args:
+            client_conf (dict, optional): A dictionary containing client configuration. If None,
+                client configuration will be loaded from the specified directory.
+            client_conf_dir (str, optional): The directory from which to load client configuration
+                if `client_conf` is None. Must be provided in that case.
+            load_conf (bool, optional): A flag indicating whether to load the client
+                configuration from the directory. Defaults to True.
+            *args: Variable length argument list for client initialization.
+            **kwargs: Arbitrary keyword arguments for client initialization.
+
+        Raises:
+            AssertionError: If `client_conf` is None and `client_conf_dir` is also None.
+
+        Note:
+            The method will create a client for each configuration found in `client_conf`,
+            initializing the client with the specified `base_url` and `api_key`.
+        Examples:
+            >>> llm = OpenAIWrapper(
+            >>>     client_conf_dir="/some/path/model_conf.yaml",
+            >>>     # load_conf=False
+            >>> )
+)
         """
         self.client_conf = {}
         if client_conf is None:
@@ -24,7 +48,8 @@ class OpenAIWrapper(object):
         else:
             self.client_conf = client_conf
 
-        for cid, conf in self.client_conf.items():
+        # self.clients = {}
+        for _, conf in self.client_conf.items():
             conf["client"] = OpenAI(
                 base_url=conf["host"],
                 api_key=conf.get("api_key", "dummy_key"),
@@ -33,8 +58,6 @@ class OpenAIWrapper(object):
             )
             if "client_type" not in conf:
                 conf["client_type"] = "chat"
-            if "model" not in conf:
-                conf["model"] = None
 
     def add_client(
         self,
@@ -45,6 +68,31 @@ class OpenAIWrapper(object):
         api_key: str = "dummy_key",
         **kwargs
     ):
+        """
+        Add a new client configuration to the client manager.
+
+        This method stores the configuration details for a new client identified by the
+        provided client ID. It constructs the host URL based on the input parameters
+        and initializes an OpenAI client instance.
+
+        Args:
+            client_id (str): Unique identifier for the client.
+            host (str): Hostname or IP address of the client.
+            port (int, optional): Port number for the client connection. Defaults to None.
+            model (str, optional): Model to use for the client. Defaults to "default_model".
+            api_key (str, optional): API key for authentication. Defaults to "dummy_key".
+            **kwargs: Additional keyword arguments passed to the OpenAI client.
+
+        Raises:
+            ValueError: If both host and port are not valid for constructing a URL.
+        Examples:
+            >>> llm.add_client(
+            >>>     client_id="rone",
+            >>>     host="127.0.0.1",
+            >>>     port=22299,
+            >>>     model="ictrek/rone:1.5b32k",
+            >>> )
+        """
         self.client_conf[client_id] = {}
         if not host.startswith('http') and port:
             host = f"http://{host}:{port}/v1"
@@ -58,18 +106,36 @@ class OpenAIWrapper(object):
         )
 
     def load_clients(self):
+        """
+        Loads client configuration from a YAML file and updates the 'host' field
+        for each client entry, ensuring the correct URL format.
+
+        This method reads the client configuration from the specified path,
+        updates the 'host' field to include the appropriate port and the
+        'http' protocol if not already specified, and stores the updated
+        configuration in the `client_conf` attribute.
+
+        Attributes:
+            client_conf_path (str): The file path to the client configuration YAML file.
+            client_conf (dict): The updated client configuration after processing.
+
+        Returns:
+            None
+        """
         with open(self.client_conf_path, 'r') as file:
             data = yaml.safe_load(file)
+
+        # 更新 host 字段
         for _, value in data.items():
             host = value.get('host', '')
             port = value.get('port', '')
-            if not host.startswith('http') and port:
+            if not host.startswith('http') and port:  # 确保有 port 才处理
                 value['host'] = f"http://{host}:{port}/v1"
         self.client_conf = data
 
     def get_resp(
         self,
-        prompt: str,
+        prompt,
         client_id: str = None,
         history: list = None,
         sys_info: str = None,
@@ -78,7 +144,7 @@ class OpenAIWrapper(object):
         image_keys: tuple = ("image_url", "url"),
         videos: list = None,
         video_keys: tuple = ("video_url", "url"),
-        model: str = None,
+        model: str=None,
         tools: list = None,
         tool_choice: str = "auto",
         stream: bool = True,
@@ -86,95 +152,234 @@ class OpenAIWrapper(object):
         **kwargs: t.Any,
     ):
         """
-        Generates a response from the model using responses.create with input=.
-        Supports optional image input if `images` is provided.
-        Also supports external tools via `tools` + `tool_choice`.
+        Generates a response from a chat model based on the given prompt and additional context.
+
+        Args:
+            prompt (str): The main text prompt to send to the chat model.
+            client_id (str, optional): Identifier for the client configuration. Defaults to None.
+            history (list, optional): A list of previous messages to provide context for the conversation. Each message should be a dictionary with "role" and "content". Defaults to None.
+            sys_info (str, optional): System-level information to set the context of the chat. Defaults to None.
+            assis_info (str, optional): Information from the assistant to be included in the conversation. Defaults to None.
+            images (list, optional): A list of images to include in the message content. Defaults to None.
+            image_keys (tuple, optional): Keys to format the image data. Must be of length 1 or 2. Defaults to ("image_url", "url").
+            model (str, optional): The model to use for generating the response. If not provided, it defaults to the one in client configuration for the given client_id.
+            tools (list, optional): List of tools to be available during the chat. Defaults to None.
+            stream (bool, optional): Whether to stream the response. Defaults to True.
+            response_model (optional): Specifies the response model to use. Defaults to None.
+            **kwargs (Any): Additional configuration parameters.
+
+        Returns:
+            Response: The response object from the chat model.
         """
-        if client_id is None:
-            raise ValueError("client_id must be provided")
-        conf = self.client_conf[client_id]
-        client = conf["client"]
-        if model is None:
-            model = conf.get("model")
-        if model is None:
-            raise ValueError("model must be specified either in client_conf or via parameter")
-
-        # Build input list
-        input_items: list[t.Any] = []
+        if not model:
+            model = self.client_conf[client_id]['model']
+
+        client = self.client_conf[client_id]['client']
+        if response_model:
+            import instructor #TODO 有些模型支持这个 instructor 的结构化输出，但实际上它调用的还是openai api的功能，以后适时删除或补全
+            client = instructor.from_openai(client)
+
+        messages = []
 
         if sys_info:
-            input_items.append({"role": "system", "content": sys_info})
+            messages.append({
+                "role": "system",
+                "content": sys_info
+            })
+
         if history:
-            input_items.extend(history)
+            messages.extend(history)
+            # history 需要符合以下格式，其中system不是必须
+            # history = [
+            #     {"role": "system", "content": "You are a helpful assistant."},
+            #     {"role": "user", "content": "message 1 content."},
+            #     {"role": "assistant", "content": "message 2 content"},
+            #     {"role": "user", "content": "message 3 content"},
+            #     {"role": "assistant", "content": "message 4 content."},
+            #     {"role": "user", "content": "message 5 content."}
+            # ]
+
+        if not model:
+            model = self.client_conf[client_id]["model"]
+        # Adjust the image_keys to be a tuple of length 3 based on its current length
+        if isinstance(image_keys, str):
+            image_keys = (image_keys,) * 3
+        elif len(image_keys) == 2:
+            image_keys = (image_keys[0],) + tuple(image_keys)
+        elif len(image_keys) == 1:
+            image_keys = (image_keys[0],) * 3
+
+        if isinstance(video_keys, str):
+            video_keys = (video_keys,) * 3
+        elif len(video_keys) == 2:
+            video_keys = (video_keys[0],) + tuple(video_keys)
+        elif len(video_keys) == 1:
+            video_keys = (video_keys[0],) * 3
+
+        content = [{
+            "type": "text",
+            "text": prompt
+        }]
+
+        if videos:
+            if isinstance(videos, str):
+                images = [videos]
+            for video in videos:
+                content.append({
+                    "type": video_keys[0],
+                    video_keys[1]: {
+                        video_keys[2]: video
+                    }
+                })
+
 
-        # Build user message
         if images:
             if isinstance(images, str):
                 images = [images]
-            multimodal_content = [
-                {"type": "input_text", "text": prompt}
-            ]
             for img in images:
-                multimodal_content.append({
-                    "type": "input_image",
-                    "image_url": img
+                content.append({
+                    "type": image_keys[0],
+                    image_keys[1]: {
+                        image_keys[2]: img
+                    }
                 })
-            user_item = {"role": "user", "content": multimodal_content}
-        else:
-            user_item = {"role": "user", "content": prompt}
+        if (not images) and (not videos):
+            content = prompt
 
-        input_items.append(user_item)
+        # Add the user's input as a message
+        messages.append({
+            "role": "user",
+            "content": content
+        })
 
         if assis_info:
-            input_items.append({"role": "assistant", "content": assis_info})
+            messages.append({
+                "role": "assistant",
+                "content": assis_info
+            })
 
-        # Prepare call parameters
-        call_params = {
-            "model": model,
-            "input": input_items,
-            **kwargs
-        }
         if tools:
-            call_params["tools"] = tools
-            call_params["tool_choice"] = tool_choice
-
-        # Call Responses API
-        if stream:
-            resp_stream = client.responses.create(
-                stream=True,
-                **call_params
+            resp = client.chat.completions.create(
+                model=model,
+                messages=messages,
+                tools=tools,
+                tool_choice=tool_choice,
+                stream=stream,
+                **kwargs
             )
-            return resp_stream
         else:
-            resp = client.responses.create(
-                stream=False,
-                **call_params
+            resp = client.chat.completions.create(
+                model=model,
+                messages=messages,
+                stream=stream,
+                **kwargs
             )
-            # Wrap to mimic chat.completions interface
-            from types import SimpleNamespace
-            text_out = getattr(resp, "output_text", "")
-            message = SimpleNamespace(content=text_out, tool_calls=None)
-            choice = SimpleNamespace(message=message, finish_reason="stop")
-            fake_resp = SimpleNamespace(choices=[choice])
-            return fake_resp
+        return resp
 
     def invoke(
         self,
-        prompt: str,
+        prompt,
         **kwargs
     ):
+        """
+        Invoke the API to get a response based on the provided prompt.
+
+        Args:
+            prompt (str): The input prompt to be processed.
+            **kwargs: Additional keyword arguments to customize the API request.
+
+        Returns:
+            dict: A dictionary containing the type of response and its contents.
+                  The possible keys are:
+                  - 'type' (str): Indicates the type of response ('text' or 'tool_calls').
+                  - 'contents' (str, optional): The text content if the response type is 'text'.
+                  - 'tool_params' (dict, optional): The parameters of the tool called if the response type is 'tool_calls'.
+
+        Examples:
+            >>> llm.invoke(
+            >>>     client_id="glm_4_flash",
+            >>>     prompt="深圳天气怎么样？",
+            >>>     tools=[TOOL_DICT['get_weather']],
+            >>> )
+            {'type': 'tool_calls',
+             'tool_parmas': Function(arguments='{"location": "Shenzhen"}', name='get_weather')}
+        """
         answer_dict = {}
-        resp = self.get_resp(prompt=prompt, stream=False, **kwargs)
-        answer_dict["type"] = "text"
-        answer_dict["contents"] = resp.choices[0].message.content
+
+        resp = self.get_resp(
+            prompt,
+            stream=False,
+            **kwargs
+        )
+        if resp.choices[0].finish_reason == "stop":
+            answer_dict["type"] = "text"
+            answer_dict["contents"] = resp.choices[0].message.content
+        elif resp.choices[0].finish_reason == "tool_calls":
+            answer_dict["type"] = "tool_calls"
+            answer_dict["tool_params"] = resp.choices[0].message.tool_calls[0].function
+
         return answer_dict
 
-    def stream(self, prompt: str, **kwargs):
-        resp_stream = self.get_resp(prompt=prompt, stream=True, **kwargs)
-        for event in resp_stream:
-            delta = getattr(event, "delta", None)
-            if delta and hasattr(delta, "content"):
-                yield {"type": "text", "content": delta.content}
+    def stream(self, prompt, **kwargs):
+        """
+        Streams responses based on the provided prompt, yielding chunks of data.
+
+        This function calls the `get_resp` method with the prompt and additional keyword arguments,
+        streaming the response in chunks. It processes each chunk to yield either tool call parameters
+        or textual content. If an error occurs while processing the chunks, it yields an error message.
+
+        Args:
+            prompt (str): The input prompt to generate responses for.
+            **kwargs: Additional keyword arguments to be passed to the `get_resp` method.
+
+        Yields:
+            dict: A dictionary with the following possible keys:
+                - type (str): Indicates the type of the response ('tool_calls', 'text', or 'error').
+                - tool_params (dict, optional): Parameters of the tool call if the type is 'tool_calls'.
+                - content (str, optional): The generated text content if the type is 'text'.
+                - message (str, optional): An error message if the type is 'error'.
+
+        Examplse:
+            >>> resp = llm.stream(
+            >>>     client_id="r1", #此模型可以进行cot
+            >>>     prompt=prompt,
+            >>>     # tools=[TOOL_DICT['get_weather']],
+            >>> )
+            >>> for i in resp:
+            >>>     if i['type'] == 'text' and i['content']:
+            >>>         print(i['content'], flush=True, end="")
+        """
+        resp = self.get_resp(prompt=prompt, stream=True, **kwargs)
+
+        for chunk in resp:
+            try:
+                choice = chunk.choices[0]
+
+                # 如果返回了 tool_calls
+                if hasattr(choice.delta, 'tool_calls') and choice.delta.tool_calls:
+                    tool_calls = choice.delta.tool_calls
+                    if tool_calls:  # 防止为空
+                        yield {
+                            "type": "tool_calls",
+                            "tool_params": tool_calls[0].function
+                        }
+                    return  # 直接返回，结束流式输出
+
+                # 返回文本内容
+                elif hasattr(choice.delta, 'content'):
+                    yield {
+                        "type": "text",
+                        "content": choice.delta.content
+                    }
+
+            except (AttributeError, IndexError) as e:
+                # 防止意外的结构异常
+                yield {
+                    "type": "error",
+                    "message": f"Stream chunk error: {str(e)}"
+                }
+                return
+
         return
 
     def embedding(
@@ -183,13 +388,28 @@ class OpenAIWrapper(object):
         texts: list[str],
         model: str = None,
         **kwargs
-    ) -> list:
-        if model is None:
+    ):
+        """
+        Generates embeddings for a list of texts using a specified model.
+
+        Args:
+            client_id (str): The ID of the client to use for generating embeddings.
+            texts (list[str]): A list of texts for which to generate embeddings.
+            model (str, optional): The model to use for generating embeddings.
+                If not provided, the model specified in the client configuration will be used.
+            **kwargs: Additional keyword arguments to be passed to the client embedding creation method.
+
+        Returns:
+            list: A list of embeddings corresponding to the input texts.
+        """
+        if not model:
             model = self.client_conf[client_id]['model']
+
         client = self.client_conf[client_id]['client']
         response = client.embeddings.create(
             input=texts,
             model=model,
             **kwargs
         )
+
         return [i.embedding for i in response.data]

{hjxdl-0.3.56.dist-info → hjxdl-0.3.58.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hjxdl
-Version: 0.3.56
+Version: 0.3.58
 Summary: A collection of functions for Jupyter notebooks
 Home-page: https://github.com/huluxiaohuowa/hdl
 Author: Jianxing Hu

{hjxdl-0.3.56.dist-info → hjxdl-0.3.58.dist-info}/RECORD

@@ -1,5 +1,5 @@
 hdl/__init__.py,sha256=GffnD0jLJdhkd-vo989v40N90sQbofkayRBwxc6TVhQ,72
-hdl/_version.py,sha256=2Ln2Sf-BSjJoFUL4Jj83SaeT5iusbHd-apGtpKFocvQ,714
+hdl/_version.py,sha256=xjPDXkoC3XkceKjo-55ZXy9kGQL-5rAj-yOgDqhc8rE,714
 hdl/args/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 hdl/args/loss_args.py,sha256=s7YzSdd7IjD24rZvvOrxLLFqMZQb9YylxKeyelSdrTk,70
 hdl/controllers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -131,12 +131,12 @@ hdl/utils/general/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU
 hdl/utils/general/glob.py,sha256=Zuf7WHU0UdUPOs9UrhxmrCiMC8GrHxQU6n3mTThv6yc,1120
 hdl/utils/general/runners.py,sha256=R0lhqABIuT43jEyjFkeio84e_PFfvAkszOP1FBlAnQ8,4927
 hdl/utils/llm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-hdl/utils/llm/chat.py,sha256=DUxvnYTPIEhhrdaXOapmSG_-o_gWe_PWla2cJ3MLHeE,28658
+hdl/utils/llm/chat.py,sha256=q0zQmf-6DeSYOrC2qDn_QFOlILjRHU69eVRUn0eIIbA,26526
 hdl/utils/llm/chatgr.py,sha256=5F5PJHe8vz3iCfi4TT54DCLRi1UeJshECdVtgvvvao0,3696
 hdl/utils/llm/embs.py,sha256=Tf0FOYrOFZp7qQpEPiSCXzlgyHH0X9HVTUtsup74a9E,7174
 hdl/utils/llm/extract.py,sha256=2sK_WJzmYIc8iuWaM9DA6Nw3_6q1O4lJ5pKpcZo-bBA,6512
 hdl/utils/llm/llama_chat.py,sha256=watcHGOaz-bv3x-yDucYlGk5f8FiqfFhwWogrl334fk,4387
-hdl/utils/llm/llm_wrapper.py,sha256=qebQkq70nGwCozqVvCfPegqnKMO7lyhdFobB8CJHXyk,6186
+hdl/utils/llm/llm_wrapper.py,sha256=90kuCEYMUAjJtjRSzwHTcQsprxaVHx8kyrtzl_aw1iY,15931
 hdl/utils/llm/ollama.py,sha256=uEdLsNAc6b56r37hNiE3nrd6oZ2lmQ0gYbVvOc9YVIM,1389
 hdl/utils/llm/vis.py,sha256=jRa5l1LHaWtohtdIKVpOH_I4yyXWTbyaLGglFHsV_0Q,28826
 hdl/utils/llm/visrag.py,sha256=0i-VrxqgiV-J7R3VPshu9oc7-rKjFJOldYik3HDXj6M,10176
@@ -146,8 +146,8 @@ hdl/utils/vis_tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSu
 hdl/utils/vis_tools/scene_detect.py,sha256=L6TFMT15QHJuOIFcLFVI_RSSSjyTVZhBEqbeUez2auU,6608
 hdl/utils/weather/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 hdl/utils/weather/weather.py,sha256=k11o6wM15kF8b9NMlEfrg68ak-SfSYLN3nOOflFUv-I,4381
-hjxdl-0.3.56.dist-info/licenses/LICENSE,sha256=lkMiSbeZHBQLB9LJEkS9-L3Z-LBC4yGnKrzHSG8RkPM,2599
-hjxdl-0.3.56.dist-info/METADATA,sha256=dYCo8TjnxT5zrnB_MyMXTkQ-T9ocPhpJmnXQuBBRtqg,1332
-hjxdl-0.3.56.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-hjxdl-0.3.56.dist-info/top_level.txt,sha256=-kxwTM5JPhylp06z3zAVO3w6_h7wtBfBo2zgM6YZoTk,4
-hjxdl-0.3.56.dist-info/RECORD,,
+hjxdl-0.3.58.dist-info/licenses/LICENSE,sha256=lkMiSbeZHBQLB9LJEkS9-L3Z-LBC4yGnKrzHSG8RkPM,2599
+hjxdl-0.3.58.dist-info/METADATA,sha256=acyVOZm7COIyMnuI-HqyziPYFpyYMHhWdEQXR45QNDc,1332
+hjxdl-0.3.58.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+hjxdl-0.3.58.dist-info/top_level.txt,sha256=-kxwTM5JPhylp06z3zAVO3w6_h7wtBfBo2zgM6YZoTk,4
+hjxdl-0.3.58.dist-info/RECORD,,