bisheng-langchain 0.2.2.4__py3-none-any.whl → 0.2.2.5__py3-none-any.whl

bisheng_langchain/chains/__init__.py

@@ -1,5 +1,6 @@
 from bisheng_langchain.chains.autogen.auto_gen import AutoGenChain
 from bisheng_langchain.chains.combine_documents.stuff import StuffDocumentsChain
+from bisheng_langchain.chains.conversational_retrieval.base import ConversationalRetrievalChain
 from bisheng_langchain.chains.retrieval.retrieval_chain import RetrievalChain
 from bisheng_langchain.chains.router.multi_rule import MultiRuleChain
 from bisheng_langchain.chains.router.rule_router import RuleBasedRouter
@@ -7,6 +8,6 @@ from bisheng_langchain.chains.router.rule_router import RuleBasedRouter
 from .loader_output import LoaderOutputChain
 
 __all__ = [
-    'StuffDocumentsChain', 'LoaderOutputChain', 'AutoGenChain', 'RuleBasedRouter', 'MultiRuleChain',
-    'RetrievalChain'
+    'StuffDocumentsChain', 'LoaderOutputChain', 'AutoGenChain', 'RuleBasedRouter',
+    'MultiRuleChain', 'RetrievalChain', 'ConversationalRetrievalChain'
 ]

bisheng_langchain/chains/conversational_retrieval/base.py

@@ -0,0 +1,115 @@
+from __future__ import annotations
+
+import inspect
+from typing import Any, Dict, List, Optional, Tuple, Union
+
+from langchain.callbacks.manager import AsyncCallbackManagerForChainRun, CallbackManagerForChainRun
+from langchain.chains.conversational_retrieval.base import \
+    ConversationalRetrievalChain as BaseConversationalRetrievalChain
+from langchain_core.messages import BaseMessage
+
+# Depending on the memory type and configuration, the chat history format may differ.
+# This needs to be consolidated.
+CHAT_TURN_TYPE = Union[Tuple[str, str], BaseMessage]
+
+_ROLE_MAP = {'human': 'Human: ', 'ai': 'Assistant: '}
+
+
+def _get_chat_history(chat_history: List[CHAT_TURN_TYPE]) -> str:
+    buffer = ''
+    for dialogue_turn in chat_history:
+        if isinstance(dialogue_turn, BaseMessage):
+            role_prefix = _ROLE_MAP.get(dialogue_turn.type, f'{dialogue_turn.type}: ')
+            buffer += f'\n{role_prefix}{dialogue_turn.content}'
+        elif isinstance(dialogue_turn, tuple):
+            human = 'Human: ' + dialogue_turn[0]
+            ai = 'Assistant: ' + dialogue_turn[1]
+            buffer += '\n' + '\n'.join([human, ai])
+        else:
+            raise ValueError(f'Unsupported chat history format: {type(dialogue_turn)}.'
+                             f' Full chat history: {chat_history} ')
+    return buffer
+
+
+class ConversationalRetrievalChain(BaseConversationalRetrievalChain):
+    """ConversationalRetrievalChain is a chain you can use to have a conversation with a character from a series."""
+
+    def _call(
+        self,
+        inputs: Dict[str, Any],
+        run_manager: Optional[CallbackManagerForChainRun] = None,
+    ) -> Dict[str, Any]:
+        _run_manager = run_manager or CallbackManagerForChainRun.get_noop_manager()
+        question = inputs['question']
+        get_chat_history = self.get_chat_history or _get_chat_history
+        chat_history_str = get_chat_history(inputs['chat_history'])
+
+        if chat_history_str:
+            # callbacks = _run_manager.get_child()
+            new_question = self.question_generator.run(question=question,
+                                                       chat_history=chat_history_str)
+        else:
+            new_question = question
+        accepts_run_manager = ('run_manager' in inspect.signature(self._get_docs).parameters)
+        if accepts_run_manager:
+            docs = self._get_docs(new_question, inputs, run_manager=_run_manager)
+        else:
+            docs = self._get_docs(new_question, inputs)  # type: ignore[call-arg]
+        output: Dict[str, Any] = {}
+        if self.response_if_no_docs_found is not None and len(docs) == 0:
+            output[self.output_key] = self.response_if_no_docs_found
+        else:
+            new_inputs = inputs.copy()
+            if self.rephrase_question:
+                new_inputs['question'] = new_question
+            new_inputs['chat_history'] = chat_history_str
+            answer = self.combine_docs_chain.run(input_documents=docs,
+                                                 callbacks=_run_manager.get_child(),
+                                                 **new_inputs)
+            output[self.output_key] = answer
+
+        if self.return_source_documents:
+            output['source_documents'] = docs
+        if self.return_generated_question:
+            output['generated_question'] = new_question
+        return output
+
+    async def _acall(
+        self,
+        inputs: Dict[str, Any],
+        run_manager: Optional[AsyncCallbackManagerForChainRun] = None,
+    ) -> Dict[str, Any]:
+        _run_manager = run_manager or AsyncCallbackManagerForChainRun.get_noop_manager()
+        question = inputs['question']
+        get_chat_history = self.get_chat_history or _get_chat_history
+        chat_history_str = get_chat_history(inputs['chat_history'])
+        if chat_history_str:
+            # callbacks = _run_manager.get_child()
+            new_question = await self.question_generator.arun(question=question,
+                                                              chat_history=chat_history_str)
+        else:
+            new_question = question
+        accepts_run_manager = ('run_manager' in inspect.signature(self._aget_docs).parameters)
+        if accepts_run_manager:
+            docs = await self._aget_docs(new_question, inputs, run_manager=_run_manager)
+        else:
+            docs = await self._aget_docs(new_question, inputs)  # type: ignore[call-arg]
+
+        output: Dict[str, Any] = {}
+        if self.response_if_no_docs_found is not None and len(docs) == 0:
+            output[self.output_key] = self.response_if_no_docs_found
+        else:
+            new_inputs = inputs.copy()
+            if self.rephrase_question:
+                new_inputs['question'] = new_question
+            new_inputs['chat_history'] = chat_history_str
+            answer = await self.combine_docs_chain.arun(input_documents=docs,
+                                                        callbacks=_run_manager.get_child(),
+                                                        **new_inputs)
+            output[self.output_key] = answer
+
+        if self.return_source_documents:
+            output['source_documents'] = docs
+        if self.return_generated_question:
+            output['generated_question'] = new_question
+        return output

bisheng_langchain/chat_models/__init__.py

@@ -1,4 +1,4 @@
-from .host_llm import CustomLLMChat, HostBaichuanChat, HostChatGLM, HostLlama2Chat, HostQwenChat
+from .host_llm import CustomLLMChat, HostBaichuanChat, HostChatGLM, HostLlama2Chat, HostQwenChat, HostYuanChat, HostYiChat
 from .minimax import ChatMinimaxAI
 from .proxy_llm import ProxyChatLLM
 from .qwen import ChatQWen
@@ -9,5 +9,6 @@ from .sensetime import SenseChat
 
 __all__ = [
     'ProxyChatLLM', 'ChatMinimaxAI', 'ChatWenxin', 'ChatZhipuAI', 'ChatXunfeiAI', 'HostChatGLM',
-    'HostBaichuanChat', 'HostLlama2Chat', 'HostQwenChat', 'CustomLLMChat', 'ChatQWen', 'SenseChat'
+    'HostBaichuanChat', 'HostLlama2Chat', 'HostQwenChat', 'CustomLLMChat', 'ChatQWen', 'SenseChat',
+    'HostYuanChat', 'HostYiChat'
 ]

bisheng_langchain/chat_models/host_llm.py

@@ -535,3 +535,31 @@ class CustomLLMChat(BaseHostChatLLM):
     def _llm_type(self) -> str:
         """Return type of chat model."""
         return 'custom_llm_chat'
+
+class HostYuanChat(BaseHostChatLLM):
+    # use custom llm chat api, api should compatiable with openai definition
+    model_name: str = Field('Yuan2-2B-Janus-hf', alias='model')
+
+    temperature: float = 1
+    top_p: float = 0.9
+    max_tokens: int = 4096
+    host_base_url: str
+
+    @property
+    def _llm_type(self) -> str:
+        """Return type of chat model."""
+        return 'yuan2'
+    
+class HostYiChat(BaseHostChatLLM):
+    # use custom llm chat api, api should compatiable with openai definition
+    model_name: str = Field('Yi-34B-Chat', alias='model')
+
+    temperature: float = 0.6
+    top_p: float = 0.8
+    max_tokens: int = 4096
+    host_base_url: str
+
+    @property
+    def _llm_type(self) -> str:
+        """Return type of chat model."""
+        return 'yi_chat'

bisheng_langchain/chat_models/sensetime.py

@@ -1,8 +1,12 @@
 from __future__ import annotations
 
+import json
 import logging
-import sys
-from typing import TYPE_CHECKING, Any, Callable, Dict, List, Mapping, Optional, Tuple, Union
+import time
+from typing import Any, Dict, List, Mapping, Optional, Tuple, Union
+
+import jwt
+from bisheng_langchain.utils.requests import Requests
 from langchain.callbacks.manager import AsyncCallbackManagerForLLMRun, CallbackManagerForLLMRun
 from langchain.chat_models.base import BaseChatModel
 from langchain.schema import ChatGeneration, ChatResult
@@ -12,19 +16,13 @@ from langchain.utils import get_from_dict_or_env
 from langchain_core.pydantic_v1 import Field, root_validator
 from tenacity import (before_sleep_log, retry, retry_if_exception_type, stop_after_attempt,
                       wait_exponential)
-from bisheng_langchain.utils.requests import Requests
-
-import time
-import requests
-import json
-
 
-import jwt
 # if TYPE_CHECKING:
 #     import jwt
 
 logger = logging.getLogger(__name__)
 
+
 def _import_pyjwt() -> Any:
     try:
         import jwt
@@ -34,19 +32,18 @@ def _import_pyjwt() -> Any:
                          'Please install it with `pip install PyJWT`.')
     return jwt
 
+
 def encode_jwt_token(ak, sk):
-    headers = {
-        "alg": "HS256",
-        "typ": "JWT"
-    }
+    headers = {'alg': 'HS256', 'typ': 'JWT'}
     payload = {
-        "iss": ak,
-        "exp": int(time.time()) + 1800, # 填写您期望的有效时间，此处示例代表当前时间+30分钟
-        "nbf": int(time.time()) - 5 # 填写您期望的生效时间，此处示例代表当前时间-5秒
+        'iss': ak,
+        'exp': int(time.time()) + 18000,  # 填写您期望的有效时间，此处示例代表当前时间+300分钟
+        'nbf': int(time.time()) - 500  # 填写您期望的生效时间，此处示例代表当前时间-500秒
     }
     token = jwt.encode(payload, sk, headers=headers)
     return token
 
+
 def _create_retry_decorator(llm):
 
     min_seconds = 1
@@ -67,7 +64,8 @@ def _convert_dict_to_message(_dict: Mapping[str, Any]) -> BaseMessage:
     if role == 'user':
         return HumanMessage(content=_dict['content'])
     elif role == 'assistant':
-        content = _dict['message'] or ''  # OpenAI returns None for tool invocations
+        content = _dict['content'] or ''  # OpenAI returns None for tool invocations
+
         if _dict.get('function_call'):
             additional_kwargs = {'function_call': dict(_dict['function_call'])}
         else:
@@ -119,7 +117,9 @@ def _convert_message_to_dict2(message: BaseMessage) -> List[dict]:
 
     return [message_dict]
 
-url = "https://api.sensenova.cn/v1/llm/chat-completions"
+
+url = 'https://api.sensenova.cn/v1/llm/chat-completions'
+
 
 class SenseChat(BaseChatModel):
 
@@ -164,22 +164,23 @@ class SenseChat(BaseChatModel):
 
     @root_validator()
     def validate_environment(cls, values: Dict) -> Dict:
-
         """Validate that api key and python package exists in environment."""
 
         _import_pyjwt()
 
-        values['access_key_id'] = get_from_dict_or_env(values, 'access_key_id',
-                                                         'ACCESS_KEY_ID')
+        values['access_key_id'] = get_from_dict_or_env(values, 'access_key_id', 'ACCESS_KEY_ID')
         values['secret_access_key'] = get_from_dict_or_env(values, 'secret_access_key',
-                                                         'SECRET_ACCESS_KEY')
+                                                           'SECRET_ACCESS_KEY')
         token = encode_jwt_token(values['access_key_id'], values['secret_access_key'])
         if isinstance(token, bytes):
             token = token.decode('utf-8')
 
         try:
-            header = {'Authorization': 'Bearer {}'.format(token), 
-                      'Content-Type': 'application/json'}
+            header = {
+                'Authorization': 'Bearer {}'.format(token),
+                'Content-Type': 'application/json'
+            }
+
             values['client'] = Requests(headers=header, )
         except AttributeError:
             raise ValueError('Try upgrading it with `pip install --upgrade requests`.')
@@ -212,8 +213,8 @@ class SenseChat(BaseChatModel):
                 'temperature': temperature,
                 'repetition_penalty': self.repetition_penalty,
                 'n': self.n,
-                "max_new_tokens": self.max_tokens,
-                'stream': False#self.streaming
+                'max_new_tokens': self.max_tokens,
+                'stream': False  # self.streaming
             }
 
             token = encode_jwt_token(self.access_key_id, self.secret_access_key)
@@ -223,6 +224,7 @@ class SenseChat(BaseChatModel):
 
             response = self.client.post(url=url, json=params).json()
             return response
+
         rsp_dict = _completion_with_retry(**kwargs)
         if 'error' in rsp_dict:
             logger.error(f'sensechat_error resp={rsp_dict}')
@@ -232,16 +234,10 @@ class SenseChat(BaseChatModel):
             # return rsp_dict['data'], rsp_dict.get('usage', '')
             return rsp_dict, rsp_dict.get('usage', '')
 
-
     async def acompletion_with_retry(self, **kwargs: Any) -> Any:
         """Use tenacity to retry the async completion call."""
         retry_decorator = _create_retry_decorator(self)
 
-        token = encode_jwt_token(self.access_key_id, self.secret_access_key)
-        if isinstance(token, bytes):
-            token = token.decode('utf-8')
-        self.client.headers.update({'Authorization': 'Bearer {}'.format(token)})
-        
         if self.streaming:
             self.client.headers.update({'Accept': 'text/event-stream'})
         else:
@@ -250,13 +246,23 @@ class SenseChat(BaseChatModel):
         @retry_decorator
         async def _acompletion_with_retry(**kwargs: Any) -> Any:
             messages = kwargs.pop('messages', '')
-            input, params = SenseChat._build_input_parameters(self.model_name,
-                                                             messages=messages,
-                                                             **kwargs)
-            inp = {'input': input, 'parameters': params, 'model': self.model_name}
+
+            inp = {
+                'messages': messages,
+                'model': self.model_name,
+                'top_p': self.top_p,
+                'temperature': self.temperature,
+                'repetition_penalty': self.repetition_penalty,
+                'n': self.n,
+                'max_new_tokens': self.max_tokens,
+                'stream': True
+            }
+
             # Use OpenAI's async api https://github.com/openai/openai-python#async-api
             async with self.client.apost(url=url, json=inp) as response:
+
                 async for line in response.content.iter_any():
+
                     if b'\n' in line:
                         for txt_ in line.split(b'\n'):
                             yield txt_.decode('utf-8').strip()
@@ -315,26 +321,32 @@ class SenseChat(BaseChatModel):
         message_dicts, params = self._create_message_dicts(messages, stop)
         params = {**params, **kwargs}
         if self.streaming:
+
             inner_completion = ''
-            role = 'assistant'
+            role = 'user'
             params['stream'] = True
             function_call: Optional[dict] = None
             async for is_error, stream_resp in self.acompletion_with_retry(messages=message_dicts,
                                                                            **params):
-                output = None
-                msg = json.loads(stream_resp)
+                if str(stream_resp).startswith('[DONE]'):
+                    continue
+                output = json.loads(stream_resp)
                 if is_error:
                     logger.error(stream_resp)
                     raise ValueError(stream_resp)
-                if 'data' in msg:
-                    output = msg['data']
-                choices = output.get('choices')
+                if 'data' in output:
+                    output = output['data']
+
+                choices = None
+                if 'choices' in output:
+                    choices = output.get('choices')
+
                 if choices:
                     for choice in choices:
-                        role = choice['message'].get('role', role)
-                        token = choice['message'].get('message', '')
+                        token = choice['delta']
+
                         inner_completion += token or ''
-                        _function_call = choice['message'].get('function_call', '')
+                        _function_call = ''
                         if run_manager:
                             await run_manager.on_llm_new_token(token)
                         if _function_call:
@@ -376,16 +388,16 @@ class SenseChat(BaseChatModel):
     def _create_chat_result(self, response: Mapping[str, Any]) -> ChatResult:
         generations = []
 
-        # print('response', response)
         def _norm_text(text):
             if text[0] == '"' and text[-1] == '"':
                 out = eval(text)
             else:
                 out = text
             return out
+
         for res in response['data']['choices']:
             res['content'] = _norm_text(res['message'])
-            res["role"] = 'user' 
+            res['role'] = 'user'
             message = _convert_dict_to_message(res)
             gen = ChatGeneration(message=message)
             generations.append(gen)

bisheng_langchain/document_loaders/elem_unstrcutured_loader.py

@@ -63,7 +63,8 @@ class ElemUnstructuredLoader(BasePDFLoader):
                  unstructured_api_url: str = None,
                  start: int = 0,
                  n: int = None,
-                 verbose: bool = False) -> None:
+                 verbose: bool = False,
+                 kwargs: dict = {}) -> None:
         """Initialize with a file path."""
         self.unstructured_api_url = unstructured_api_url
         self.unstructured_api_key = unstructured_api_key
@@ -71,18 +72,18 @@ class ElemUnstructuredLoader(BasePDFLoader):
         self.file_name = file_name
         self.start = start
         self.n = n
+        self.extra_kwargs = kwargs
         super().__init__(file_path)
 
     def load(self) -> List[Document]:
         """Load given path as pages."""
         b64_data = base64.b64encode(open(self.file_path, 'rb').read()).decode()
+        parameters = {'start': self.start, 'n': self.n}
+        parameters.update(self.extra_kwargs)
         payload = dict(filename=os.path.basename(self.file_name),
                        b64_data=[b64_data],
                        mode='partition',
-                       parameters={
-                           'start': self.start,
-                           'n': self.n
-                       })
+                       parameters=parameters)
 
         resp = requests.post(self.unstructured_api_url, headers=self.headers, json=payload).json()
 
@@ -112,18 +113,23 @@ class ElemUnstructuredLoaderV0(BasePDFLoader):
                  unstructured_api_url: str = None,
                  start: int = 0,
                  n: int = None,
-                 verbose: bool = False) -> None:
+                 verbose: bool = False,
+                 kwargs: dict = {}) -> None:
         """Initialize with a file path."""
         self.unstructured_api_url = unstructured_api_url
         self.unstructured_api_key = unstructured_api_key
+        self.start = start
+        self.n = n
         self.headers = {'Content-Type': 'application/json'}
         self.file_name = file_name
+        self.extra_kwargs = kwargs
         super().__init__(file_path)
 
     def load(self) -> List[Document]:
         b64_data = base64.b64encode(open(self.file_path, 'rb').read()).decode()
         payload = dict(filename=os.path.basename(self.file_name), b64_data=[b64_data], mode='text')
-
+        payload.update({'start': self.start, 'n': self.n})
+        payload.update(self.extra_kwargs)
         resp = requests.post(self.unstructured_api_url, headers=self.headers, json=payload).json()
 
         if 200 != resp.get('status_code'):

{bisheng_langchain-0.2.2.4.dist-info → bisheng_langchain-0.2.2.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: bisheng-langchain
-Version: 0.2.2.4
+Version: 0.2.2.5
 Summary: bisheng langchain modules
 Home-page: https://github.com/dataelement/bisheng
 Author: DataElem

{bisheng_langchain-0.2.2.4.dist-info → bisheng_langchain-0.2.2.5.dist-info}/RECORD

@@ -12,24 +12,26 @@ bisheng_langchain/autogen_role/assistant.py,sha256=VGCoxJaRxRG6ZIJa2TsxcLZbMbF4K
 bisheng_langchain/autogen_role/custom.py,sha256=8xxtAzNF_N1fysyChynVD19t659Qvtcyj_LNiOrE7ew,2499
 bisheng_langchain/autogen_role/groupchat_manager.py,sha256=O9XIove5yzyF_g3K5DnF-Fasdx0sUrRWMogYgEDYJAI,2314
 bisheng_langchain/autogen_role/user.py,sha256=lISbJN5yFsUXHnDCUwr5t6R8O8K3dOMspH4l4_kITnE,5885
-bisheng_langchain/chains/__init__.py,sha256=QWryJz0vlTAFAFrzQW672hvrNXjV3Hr4oJyg92UPlM4,551
+bisheng_langchain/chains/__init__.py,sha256=bZXTCzBbsaU9ks90SU5T2u2py006sArwKZJgCc8BNn8,679
 bisheng_langchain/chains/loader_output.py,sha256=02ZercAFaudStTZ4t7mcVkGRj5pD78HZ6NO8HbmbDH8,1903
 bisheng_langchain/chains/autogen/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 bisheng_langchain/chains/autogen/auto_gen.py,sha256=QIkfCO9-VN2wRkl3_TWVj-JkdL2dqMQNy93j3uB401s,3270
 bisheng_langchain/chains/combine_documents/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 bisheng_langchain/chains/combine_documents/stuff.py,sha256=z_E_wfhJrAYWcNVRPomPm5fGRDI3hqoC52wcMzgzxVA,2369
+bisheng_langchain/chains/conversational_retrieval/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bisheng_langchain/chains/conversational_retrieval/base.py,sha256=XiqBqov6No-wTVCou6qyMT5p2JQgoQI7OLQOYH8XUos,5313
 bisheng_langchain/chains/question_answering/__init__.py,sha256=_gOZMc-SWprK6xc-Jj64jcr9nc-G4YkZbEYwfJNq_bY,8795
 bisheng_langchain/chains/retrieval/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 bisheng_langchain/chains/retrieval/retrieval_chain.py,sha256=7VLJ-IPVjKfmAVgVET4cvKCO9DCMxwsGgVhW-wz5RZM,3050
 bisheng_langchain/chains/router/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 bisheng_langchain/chains/router/multi_rule.py,sha256=BiFryj3-7rOxfttD-MyOkKWLCSGB9LVYd2rjOsIfQC8,375
 bisheng_langchain/chains/router/rule_router.py,sha256=R2YRUnwn7s_7DbsSn27uPn4cIV0D-5iXEORXir0tNGM,1835
-bisheng_langchain/chat_models/__init__.py,sha256=gMWEZVjACpPjHehExg6HwDXK6XUDT4sSDXceW3NyC6E,539
-bisheng_langchain/chat_models/host_llm.py,sha256=phIBLY7AoGPIIxl9saFV2XAcRvgaJ8XUJA06bqiN8Uw,21638
+bisheng_langchain/chat_models/__init__.py,sha256=7NuGJAUgeCF9yDqe7D3Yw69_5COlsExg811TSDErpps,599
+bisheng_langchain/chat_models/host_llm.py,sha256=zbrWUf9Vvc9_8dlVLPoY7Cm0NL7WhE9DSd5F7xYhY2A,22420
 bisheng_langchain/chat_models/minimax.py,sha256=JLs_f6vWD9beZYUtjD4FG28G8tZHrGUAWOwdLIuJomw,13901
 bisheng_langchain/chat_models/proxy_llm.py,sha256=wzVBZik9WC3-f7kyQ1eu3Ooibqpcocln08knf5lV1Nw,17082
 bisheng_langchain/chat_models/qwen.py,sha256=jGx_tW-LPxfegE6NvY6wID8ps2SsP813atjXnc04C-s,18841
-bisheng_langchain/chat_models/sensetime.py,sha256=ngnj0Yzt_iwEyj_c9JkS_lmClRuRxPo5VFWGtAj5rrQ,17353
+bisheng_langchain/chat_models/sensetime.py,sha256=fuQ5yYGO5F7o7iQ7us17MlL4TAWRRFCCpNN9bAF-ydc,17056
 bisheng_langchain/chat_models/wenxin.py,sha256=OBXmFWkUWZMu1lUz6hPAEawsbAcdgMWcm9WkJJLZyng,13671
 bisheng_langchain/chat_models/xunfeiai.py,sha256=Yz09-I8u6XhGVnT5mdel15Z3CCQZqApJkgnaxyiZNFk,14037
 bisheng_langchain/chat_models/zhipuai.py,sha256=KokWmDDwljsV2iFiRXZlylIaQRw4jDOq5aCnat53wnQ,14887
@@ -46,7 +48,7 @@ bisheng_langchain/document_loaders/custom_kv.py,sha256=sUKeK0e8-cCmKyj1FsR7SzBNW
 bisheng_langchain/document_loaders/elem_html.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 bisheng_langchain/document_loaders/elem_image.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 bisheng_langchain/document_loaders/elem_pdf.py,sha256=K-TXILGNFLFjavhun_MFbUF4t2_WGA3Z-kbnr75lmW8,22243
-bisheng_langchain/document_loaders/elem_unstrcutured_loader.py,sha256=N2jCmizi9gIsAO38zWL1zOzfNhoo_XmNIX7fteSeR0Q,4883
+bisheng_langchain/document_loaders/elem_unstrcutured_loader.py,sha256=bJQObxHnk8FaF8RUBkqODzgeikrZ8wdl_TQPa2oEoQo,5169
 bisheng_langchain/document_loaders/universal_kv.py,sha256=dJF_GQGKBMUjB_kX9CSp7xZRhXgwVuGPbMIzJwPh-C0,4063
 bisheng_langchain/document_loaders/parsers/__init__.py,sha256=OOM_FJkwaU-zNS58fASw0TH8FNT6VXKb0VrvisgdrII,171
 bisheng_langchain/document_loaders/parsers/ellm_client.py,sha256=B4Dea8xXXnGvB9j2OXv53HILNUmnWeNJz9ssNM-2fLM,1760
@@ -70,7 +72,7 @@ bisheng_langchain/vectorstores/__init__.py,sha256=zCZgDe7LyQ0iDkfcm5UJ5NxwKQSRHn
 bisheng_langchain/vectorstores/elastic_keywords_search.py,sha256=gt_uw_fSMcEZWxbiA3V0RyA-utLOZlUY-qxdwnsfZks,12664
 bisheng_langchain/vectorstores/milvus.py,sha256=44ZbDsIxdsbUnHOpEpCdrW5zvWnYvDdAVoDKjCFoyYI,34424
 bisheng_langchain/vectorstores/retriever.py,sha256=hj4nAAl352EV_ANnU2OHJn7omCH3nBK82ydo14KqMH4,4353
-bisheng_langchain-0.2.2.4.dist-info/METADATA,sha256=az16JYt0nlq8WIK1Uek26Qi3-w99KBRcAT9pGUb8nAE,2299
-bisheng_langchain-0.2.2.4.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-bisheng_langchain-0.2.2.4.dist-info/top_level.txt,sha256=Z6pPNyCo4ihyr9iqGQbH8sJiC4dAUwA_mAyGRQB5_Fs,18
-bisheng_langchain-0.2.2.4.dist-info/RECORD,,
+bisheng_langchain-0.2.2.5.dist-info/METADATA,sha256=zPkSGdTgG56TrcN9xLWKEv02k_Wtg2WRqkCa1yoigtE,2299
+bisheng_langchain-0.2.2.5.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+bisheng_langchain-0.2.2.5.dist-info/top_level.txt,sha256=Z6pPNyCo4ihyr9iqGQbH8sJiC4dAUwA_mAyGRQB5_Fs,18
+bisheng_langchain-0.2.2.5.dist-info/RECORD,,