hjxdl 0.3.54__py3-none-any.whl → 0.3.56__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.54'
-__version_tuple__ = version_tuple = (0, 3, 54)
+__version__ = version = '0.3.56'
+__version_tuple__ = version_tuple = (0, 3, 56)
 
-__commit_id__ = commit_id = 'gd7cc5b09f'
+__commit_id__ = commit_id = 'g5d6407784'

hdl/utils/llm/llm_wrapper.py

@@ -3,7 +3,6 @@ import typing as t
 
 from openai import OpenAI
 
-
 class OpenAIWrapper(object):
     def __init__(
         self,
@@ -15,29 +14,6 @@ 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:
@@ -48,8 +24,7 @@ class OpenAIWrapper(object):
         else:
             self.client_conf = client_conf
 
-        # self.clients = {}
-        for _, conf in self.client_conf.items():
+        for cid, conf in self.client_conf.items():
             conf["client"] = OpenAI(
                 base_url=conf["host"],
                 api_key=conf.get("api_key", "dummy_key"),
@@ -58,6 +33,8 @@ 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,
@@ -68,31 +45,6 @@ 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"
@@ -106,36 +58,18 @@ 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:  # 确保有 port 才处理
+            if not host.startswith('http') and port:
                 value['host'] = f"http://{host}:{port}/v1"
         self.client_conf = data
 
     def get_resp(
         self,
-        prompt,
+        prompt: str,
         client_id: str = None,
         history: list = None,
         sys_info: str = None,
@@ -144,7 +78,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,
@@ -152,234 +86,95 @@ class OpenAIWrapper(object):
         **kwargs: t.Any,
     ):
         """
-        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.
+        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`.
         """
-        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 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 sys_info:
-            messages.append({
-                "role": "system",
-                "content": sys_info
-            })
-
+            input_items.append({"role": "system", "content": sys_info})
         if 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
-                    }
-                })
-
+            input_items.extend(history)
 
+        # Build user message
         if images:
             if isinstance(images, str):
                 images = [images]
+            multimodal_content = [
+                {"type": "input_text", "text": prompt}
+            ]
             for img in images:
-                content.append({
-                    "type": image_keys[0],
-                    image_keys[1]: {
-                        image_keys[2]: img
-                    }
+                multimodal_content.append({
+                    "type": "input_image",
+                    "image_url": img
                 })
-        if (not images) and (not videos):
-            content = prompt
+            user_item = {"role": "user", "content": multimodal_content}
+        else:
+            user_item = {"role": "user", "content": prompt}
 
-        # Add the user's input as a message
-        messages.append({
-            "role": "user",
-            "content": content
-        })
+        input_items.append(user_item)
 
         if assis_info:
-            messages.append({
-                "role": "assistant",
-                "content": assis_info
-            })
+            input_items.append({"role": "assistant", "content": assis_info})
 
+        # Prepare call parameters
+        call_params = {
+            "model": model,
+            "input": input_items,
+            **kwargs
+        }
         if tools:
-            resp = client.chat.completions.create(
-                model=model,
-                messages=messages,
-                tools=tools,
-                tool_choice=tool_choice,
-                stream=stream,
-                **kwargs
+            call_params["tools"] = tools
+            call_params["tool_choice"] = tool_choice
+
+        # Call Responses API
+        if stream:
+            resp_stream = client.responses.create(
+                stream=True,
+                **call_params
             )
+            return resp_stream
         else:
-            resp = client.chat.completions.create(
-                model=model,
-                messages=messages,
-                stream=stream,
-                **kwargs
+            resp = client.responses.create(
+                stream=False,
+                **call_params
             )
-        return resp
+            # 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
 
     def invoke(
         self,
-        prompt,
+        prompt: str,
         **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,
-            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
-
+        resp = self.get_resp(prompt=prompt, stream=False, **kwargs)
+        answer_dict["type"] = "text"
+        answer_dict["contents"] = resp.choices[0].message.content
         return answer_dict
 
-    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
-
+    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}
         return
 
     def embedding(
@@ -388,28 +183,13 @@ class OpenAIWrapper(object):
         texts: list[str],
         model: str = None,
         **kwargs
-    ):
-        """
-        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:
+    ) -> list:
+        if model is None:
             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.54.dist-info → hjxdl-0.3.56.dist-info}/METADATA

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

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

@@ -1,5 +1,5 @@
 hdl/__init__.py,sha256=GffnD0jLJdhkd-vo989v40N90sQbofkayRBwxc6TVhQ,72
-hdl/_version.py,sha256=_Y5lo8qH4jdRcyRYZCDKbaSN12zS_WhJUDg_HwZG0HU,714
+hdl/_version.py,sha256=2Ln2Sf-BSjJoFUL4Jj83SaeT5iusbHd-apGtpKFocvQ,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
@@ -136,7 +136,7 @@ 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=90kuCEYMUAjJtjRSzwHTcQsprxaVHx8kyrtzl_aw1iY,15931
+hdl/utils/llm/llm_wrapper.py,sha256=qebQkq70nGwCozqVvCfPegqnKMO7lyhdFobB8CJHXyk,6186
 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.54.dist-info/licenses/LICENSE,sha256=lkMiSbeZHBQLB9LJEkS9-L3Z-LBC4yGnKrzHSG8RkPM,2599
-hjxdl-0.3.54.dist-info/METADATA,sha256=cyCXEGZj5dolhng5yUMe5XN54Ja_N00RLijtq12XELU,1332
-hjxdl-0.3.54.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-hjxdl-0.3.54.dist-info/top_level.txt,sha256=-kxwTM5JPhylp06z3zAVO3w6_h7wtBfBo2zgM6YZoTk,4
-hjxdl-0.3.54.dist-info/RECORD,,
+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,,