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

bisheng_langchain/autogen_role/assistant.py

@@ -1,9 +1,11 @@
 """Chain that runs an arbitrary python function."""
 import logging
-from typing import Any, Awaitable, Callable, Dict, List, Optional
+import os
+from typing import Callable, Dict, Optional
 
 import openai
 from autogen import AssistantAgent
+from langchain.base_language import BaseLanguageModel
 
 logger = logging.getLogger(__name__)
 
@@ -33,22 +35,32 @@ Reply "TERMINATE" in the end when everything is done.
         openai_api_base: Optional[str] = '',  # when llm_flag=True, need to set
         openai_proxy: Optional[str] = '',  # when llm_flag=True, need to set
         temperature: Optional[float] = 0,  # when llm_flag=True, need to set
-        system_message: Optional[str] = DEFAULT_SYSTEM_MESSAGE,  # agent system message, llm or group chat manage will use # noqa
+        api_type: Optional[str] = None,  # when llm_flag=True, need to set
+        api_version: Optional[str] = None,  # when llm_flag=True, need to set
+        llm: Optional[BaseLanguageModel] = None,
+        system_message: Optional[
+            str] = DEFAULT_SYSTEM_MESSAGE,  # agent system message, llm or group chat manage will use # noqa
         is_termination_msg: Optional[Callable[[Dict], bool]] = None,
         **kwargs,
     ):
-        is_termination_msg = (
-            is_termination_msg if is_termination_msg is not None else (lambda x: x.get("content") == "TERMINATE")
-        )
+        is_termination_msg = (is_termination_msg if is_termination_msg is not None else
+                              (lambda x: x.get('content') == 'TERMINATE'))
         if openai_proxy:
             openai.proxy = {'https': openai_proxy, 'http': openai_proxy}
+        else:
+            openai.proxy = None
         if openai_api_base:
             openai.api_base = openai_api_base
+        else:
+            openai.api_base = os.environ.get('OPENAI_API_BASE', 'https://api.openai.com/v1')
 
         config_list = [
             {
                 'model': model_name,
                 'api_key': openai_api_key,
+                'api_base': openai_api_base,
+                'api_type': api_type,
+                'api_version': api_version,
             },
         ]
         llm_config = {
@@ -61,9 +73,10 @@ Reply "TERMINATE" in the end when everything is done.
         super().__init__(
             name,
             llm_config=llm_config,
+            llm=llm,
             system_message=system_message,
             is_termination_msg=is_termination_msg,
             max_consecutive_auto_reply=None,
-            human_input_mode="NEVER",
+            human_input_mode='NEVER',
             code_execution_config=False,
         )

bisheng_langchain/autogen_role/custom.py

@@ -1,4 +1,3 @@
-
 from typing import Any, Awaitable, Callable, Dict, List, Optional, Union
 
 from autogen import Agent, ConversableAgent
@@ -15,14 +14,13 @@ class AutoGenCustomRole(ConversableAgent):
         coroutine: Optional[Callable[..., Awaitable[str]]] = None,
         **kwargs,
     ):
-        super().__init__(
-            name=name,
-            system_message=system_message,
-            human_input_mode='NEVER',
-            code_execution_config=False,
-            llm_config=False,
-            **kwargs,
-        )
+        super().__init__(name=name,
+                         system_message=system_message,
+                         human_input_mode='NEVER',
+                         code_execution_config=False,
+                         llm_config=False,
+                         llm=None,
+                         **kwargs)
         self.func = func
         self.coroutine = coroutine
         self.register_reply(Agent, AutoGenCustomRole.generate_custom_reply)

bisheng_langchain/autogen_role/groupchat_manager.py

@@ -1,9 +1,11 @@
 """Chain that runs an arbitrary python function."""
 import logging
+import os
 from typing import List, Optional
 
 import openai
 from autogen import Agent, GroupChat, GroupChatManager
+from langchain.base_language import BaseLanguageModel
 
 from .user import AutoGenUser
 
@@ -13,6 +15,7 @@ logger = logging.getLogger(__name__)
 class AutoGenGroupChatManager(GroupChatManager):
     """A chat manager agent that can manage a group chat of multiple agents.
     """
+
     def __init__(
         self,
         agents: List[Agent],
@@ -22,7 +25,10 @@ class AutoGenGroupChatManager(GroupChatManager):
         openai_api_base: Optional[str] = '',
         openai_proxy: Optional[str] = '',
         temperature: Optional[float] = 0,
+        api_type: Optional[str] = None,  # when llm_flag=True, need to set
+        api_version: Optional[str] = None,  # when llm_flag=True, need to set
         name: Optional[str] = 'chat_manager',
+        llm: Optional[BaseLanguageModel] = None,
         system_message: Optional[str] = 'Group chat manager.',
         **kwargs,
     ):
@@ -33,13 +39,20 @@ class AutoGenGroupChatManager(GroupChatManager):
 
         if openai_proxy:
             openai.proxy = {'https': openai_proxy, 'http': openai_proxy}
+        else:
+            openai.proxy = None
         if openai_api_base:
             openai.api_base = openai_api_base
+        else:
+            openai.api_base = os.environ.get('OPENAI_API_BASE', 'https://api.openai.com/v1')
 
         config_list = [
             {
                 'model': model_name,
                 'api_key': openai_api_key,
+                'api_base': openai_api_base,
+                'api_type': api_type,
+                'api_version': api_version,
             },
         ]
         llm_config = {
@@ -52,6 +65,7 @@ class AutoGenGroupChatManager(GroupChatManager):
         super().__init__(
             groupchat=groupchat,
             llm_config=llm_config,
+            llm=llm,
             name=name,
             system_message=system_message,
         )

bisheng_langchain/autogen_role/user.py

@@ -1,9 +1,11 @@
 """Chain that runs an arbitrary python function."""
 import logging
+import os
 from typing import Callable, Dict, Optional
 
 import openai
 from autogen import UserProxyAgent
+from langchain.base_language import BaseLanguageModel
 
 logger = logging.getLogger(__name__)
 
@@ -25,6 +27,9 @@ class AutoGenUserProxyAgent(UserProxyAgent):
         openai_api_base: Optional[str] = '',  # when llm_flag=True, need to set
         openai_proxy: Optional[str] = '',  # when llm_flag=True, need to set
         temperature: Optional[float] = 0,  # when llm_flag=True, need to set
+        api_type: Optional[str] = None,  # when llm_flag=True, need to set
+        api_version: Optional[str] = None,  # when llm_flag=True, need to set
+        llm: Optional[BaseLanguageModel] = None,
         system_message: Optional[
             str] = '',  # agent system message, llm or group chat manage will use
         is_termination_msg: Optional[Callable[[Dict], bool]] = None,
@@ -44,12 +49,19 @@ class AutoGenUserProxyAgent(UserProxyAgent):
         if llm_flag:
             if openai_proxy:
                 openai.proxy = {'https': openai_proxy, 'http': openai_proxy}
+            else:
+                openai.proxy = None
             if openai_api_base:
                 openai.api_base = openai_api_base
+            else:
+                openai.api_base = os.environ.get('OPENAI_API_BASE', 'https://api.openai.com/v1')
             config_list = [
                 {
                     'model': model_name,
                     'api_key': openai_api_key,
+                    'api_base': openai_api_base,
+                    'api_type': api_type,
+                    'api_version': api_version,
                 },
             ]
             llm_config = {
@@ -68,6 +80,7 @@ class AutoGenUserProxyAgent(UserProxyAgent):
                          function_map=function_map,
                          code_execution_config=code_execution_config,
                          llm_config=llm_config,
+                         llm=llm,
                          system_message=system_message)
 
 
@@ -96,6 +109,7 @@ class AutoGenUser(UserProxyAgent):
                          human_input_mode=human_input_mode,
                          code_execution_config=code_execution_config,
                          llm_config=llm_config,
+                         llm=None,
                          system_message=system_message)
 
 
@@ -126,4 +140,5 @@ class AutoGenCoder(UserProxyAgent):
                          function_map=function_map,
                          code_execution_config=code_execution_config,
                          llm_config=llm_config,
+                         llm=None,
                          system_message=system_message)

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,12 +1,14 @@
-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
 from .wenxin import ChatWenxin
 from .xunfeiai import ChatXunfeiAI
 from .zhipuai import ChatZhipuAI
+from .sensetime import SenseChat 
 
 __all__ = [
     'ProxyChatLLM', 'ChatMinimaxAI', 'ChatWenxin', 'ChatZhipuAI', 'ChatXunfeiAI', 'HostChatGLM',
-    'HostBaichuanChat', 'HostLlama2Chat', 'HostQwenChat', 'CustomLLMChat', 'ChatQWen'
+    '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

@@ -0,0 +1,437 @@
+from __future__ import annotations
+
+import json
+import logging
+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
+from langchain.schema.messages import (AIMessage, BaseMessage, ChatMessage, FunctionMessage,
+                                       HumanMessage, SystemMessage)
+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)
+
+# if TYPE_CHECKING:
+#     import jwt
+
+logger = logging.getLogger(__name__)
+
+
+def _import_pyjwt() -> Any:
+    try:
+        import jwt
+    except ImportError:
+        raise ValueError('Could not import jwt python package. '
+                         'This is needed in order to calculate get_token_ids. '
+                         'Please install it with `pip install PyJWT`.')
+    return jwt
+
+
+def encode_jwt_token(ak, sk):
+    headers = {'alg': 'HS256', 'typ': 'JWT'}
+    payload = {
+        '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
+    max_seconds = 20
+    # Wait 2^x * 1 second between each retry starting with
+    # 4 seconds, then up to 10 seconds, then 10 seconds afterwards
+    return retry(
+        reraise=True,
+        stop=stop_after_attempt(llm.max_retries),
+        wait=wait_exponential(multiplier=1, min=min_seconds, max=max_seconds),
+        retry=(retry_if_exception_type(Exception)),
+        before_sleep=before_sleep_log(logger, logging.WARNING),
+    )
+
+
+def _convert_dict_to_message(_dict: Mapping[str, Any]) -> BaseMessage:
+    role = _dict['role']
+    if role == 'user':
+        return HumanMessage(content=_dict['content'])
+    elif role == 'assistant':
+        content = _dict['content'] or ''  # OpenAI returns None for tool invocations
+
+        if _dict.get('function_call'):
+            additional_kwargs = {'function_call': dict(_dict['function_call'])}
+        else:
+            additional_kwargs = {}
+        return AIMessage(content=content, additional_kwargs=additional_kwargs)
+    elif role == 'system':
+        return SystemMessage(content=_dict['content'])
+    elif role == 'function':
+        return FunctionMessage(content=_dict['content'], name=_dict['name'])
+    else:
+        return ChatMessage(content=_dict['content'], role=role)
+
+
+def _convert_message_to_dict(message: BaseMessage) -> dict:
+    if isinstance(message, ChatMessage):
+        message_dict = {'role': message.role, 'content': message.content}
+    elif isinstance(message, HumanMessage):
+        message_dict = {'role': 'user', 'content': message.content}
+    elif isinstance(message, AIMessage):
+        message_dict = {'role': 'assistant', 'content': message.content}
+    elif isinstance(message, SystemMessage):
+        message_dict = {'role': 'system', 'content': message.content}
+        # raise ValueError(f"not support system role {message}")
+
+    elif isinstance(message, FunctionMessage):
+        raise ValueError(f'not support funciton {message}')
+    else:
+        raise ValueError(f'Got unknown type {message}')
+
+    # if "name" in message.additional_kwargs:
+    #     message_dict["name"] = message.additional_kwargs["name"]
+    return message_dict
+
+
+def _convert_message_to_dict2(message: BaseMessage) -> List[dict]:
+    if isinstance(message, ChatMessage):
+        message_dict = {'role': message.role, 'content': message.content}
+    elif isinstance(message, HumanMessage):
+        message_dict = {'role': 'user', 'content': message.content}
+    elif isinstance(message, AIMessage):
+        message_dict = {'role': 'assistant', 'content': message.content}
+    elif isinstance(message, SystemMessage):
+        raise ValueError(f'not support system role {message}')
+
+    elif isinstance(message, FunctionMessage):
+        raise ValueError(f'not support funciton {message}')
+    else:
+        raise ValueError(f'Got unknown type {message}')
+
+    return [message_dict]
+
+
+url = 'https://api.sensenova.cn/v1/llm/chat-completions'
+
+
+class SenseChat(BaseChatModel):
+
+    client: Optional[Any]  #: :meta private:
+    model_name: str = Field(default='SenseChat', alias='model')
+    """Model name to use."""
+    temperature: float = 0.8
+    top_p: float = 0.7
+    """What sampling temperature to use."""
+    model_kwargs: Optional[Dict[str, Any]] = Field(default_factory=dict)
+    """Holds any model parameters valid for `create` call not explicitly specified."""
+    access_key_id: Optional[str] = None
+    secret_access_key: Optional[str] = None
+
+    repetition_penalty: float = 1.05
+    request_timeout: Optional[Union[float, Tuple[float, float]]] = None
+    """Timeout for requests to OpenAI completion API. Default is 600 seconds."""
+    max_retries: Optional[int] = 6
+    """Maximum number of retries to make when generating."""
+    streaming: Optional[bool] = False
+    """Whether to stream the results or not."""
+    n: Optional[int] = 1
+    """Number of chat completions to generate for each prompt."""
+    max_tokens: Optional[int] = 1024
+    """Maximum number of tokens to generate."""
+    tiktoken_model_name: Optional[str] = None
+    """The model name to pass to tiktoken when using this class.
+    Tiktoken is used to count the number of tokens in documents to constrain
+    them to be under a certain limit. By default, when set to None, this will
+    be the same as the embedding model name. However, there are some cases
+    where you may want to use this Embedding class with a model name not
+    supported by tiktoken. This can include when using Azure embeddings or
+    when using one of the many model providers that expose an OpenAI-like
+    API but with different models. In those cases, in order to avoid erroring
+    when tiktoken is called, you can specify a model name to use here."""
+    verbose: Optional[bool] = False
+
+    class Config:
+        """Configuration for this pydantic object."""
+
+        allow_population_by_field_name = True
+
+    @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['secret_access_key'] = get_from_dict_or_env(values, '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'
+            }
+
+            values['client'] = Requests(headers=header, )
+        except AttributeError:
+            raise ValueError('Try upgrading it with `pip install --upgrade requests`.')
+        return values
+
+    @property
+    def _default_params(self) -> Dict[str, Any]:
+        """Get the default parameters for calling ZhipuAI API."""
+        return {
+            'model': self.model_name,
+            'temperature': self.temperature,
+            'top_p': self.top_p,
+            'max_tokens': self.max_tokens,
+            **self.model_kwargs,
+        }
+
+    def completion_with_retry(self, **kwargs: Any) -> Any:
+        retry_decorator = _create_retry_decorator(self)
+
+        @retry_decorator
+        def _completion_with_retry(**kwargs: Any) -> Any:
+            messages = kwargs.get('messages')
+            temperature = kwargs.get('temperature')
+            top_p = kwargs.get('top_p')
+            # messages
+            params = {
+                'messages': messages,
+                'model': self.model_name,
+                'top_p': top_p,
+                'temperature': temperature,
+                'repetition_penalty': self.repetition_penalty,
+                'n': self.n,
+                'max_new_tokens': self.max_tokens,
+                'stream': False  # self.streaming
+            }
+
+            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)})
+
+            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}')
+            message = rsp_dict['error']['message']
+            raise Exception(message)
+        else:
+            # 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)
+
+        if self.streaming:
+            self.client.headers.update({'Accept': 'text/event-stream'})
+        else:
+            self.client.headers.pop('Accept', '')
+
+        @retry_decorator
+        async def _acompletion_with_retry(**kwargs: Any) -> Any:
+            messages = kwargs.pop('messages', '')
+
+            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()
+                    else:
+                        yield line.decode('utf-8').strip()
+
+        async for response in _acompletion_with_retry(**kwargs):
+            is_error = False
+            if response:
+                if response.startswith('event:error'):
+                    is_error = True
+                elif response.startswith('data:'):
+                    yield (is_error, response[len('data:'):])
+                    if is_error:
+                        break
+                elif response.startswith('{'):
+                    yield (is_error, response)
+                else:
+                    continue
+
+    def _combine_llm_outputs(self, llm_outputs: List[Optional[dict]]) -> dict:
+        overall_token_usage: dict = {}
+        for output in llm_outputs:
+            if output is None:
+                # Happens in streaming
+                continue
+            token_usage = output['token_usage']
+            for k, v in token_usage.items():
+                if k in overall_token_usage:
+                    overall_token_usage[k] += v
+                else:
+                    overall_token_usage[k] = v
+        return {'token_usage': overall_token_usage, 'model_name': self.model_name}
+
+    def _generate(
+        self,
+        messages: List[BaseMessage],
+        stop: Optional[List[str]] = None,
+        run_manager: Optional[CallbackManagerForLLMRun] = None,
+        **kwargs: Any,
+    ) -> ChatResult:
+
+        message_dicts, params = self._create_message_dicts(messages, stop)
+        params = {**params, **kwargs}
+        response, usage = self.completion_with_retry(messages=message_dicts, **params)
+
+        return self._create_chat_result(response)
+
+    async def _agenerate(
+        self,
+        messages: List[BaseMessage],
+        stop: Optional[List[str]] = None,
+        run_manager: Optional[AsyncCallbackManagerForLLMRun] = None,
+        **kwargs: Any,
+    ) -> ChatResult:
+        message_dicts, params = self._create_message_dicts(messages, stop)
+        params = {**params, **kwargs}
+        if self.streaming:
+
+            inner_completion = ''
+            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):
+                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 output:
+                    output = output['data']
+
+                choices = None
+                if 'choices' in output:
+                    choices = output.get('choices')
+
+                if choices:
+                    for choice in choices:
+                        token = choice['delta']
+
+                        inner_completion += token or ''
+                        _function_call = ''
+                        if run_manager:
+                            await run_manager.on_llm_new_token(token)
+                        if _function_call:
+                            if function_call is None:
+                                function_call = _function_call
+                            else:
+                                function_call['arguments'] += _function_call['arguments']
+            message = _convert_dict_to_message({
+                'content': inner_completion,
+                'role': role,
+                'function_call': function_call,
+            })
+            return ChatResult(generations=[ChatGeneration(message=message)])
+        else:
+            return self._generate(messages, stop, run_manager, **kwargs)
+
+    def _create_message_dicts(
+            self, messages: List[BaseMessage],
+            stop: Optional[List[str]]) -> Tuple[List[Dict[str, Any]], Dict[str, Any]]:
+        params = dict(self._client_params)
+        if stop is not None:
+            if 'stop' in params:
+                raise ValueError('`stop` found in both the input and default params.')
+            params['stop'] = stop
+
+        system_content = ''
+        message_dicts = []
+        for m in messages:
+            if m.type == 'system':
+                system_content += m.content
+                continue
+            message_dicts.extend(_convert_message_to_dict2(m))
+
+        if system_content:
+            message_dicts[-1]['content'] = system_content + message_dicts[-1]['content']
+
+        return message_dicts, params
+
+    def _create_chat_result(self, response: Mapping[str, Any]) -> ChatResult:
+        generations = []
+
+        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'
+            message = _convert_dict_to_message(res)
+            gen = ChatGeneration(message=message)
+            generations.append(gen)
+
+        llm_output = {'token_usage': response['data']['usage'], 'model_name': self.model_name}
+        return ChatResult(generations=generations, llm_output=llm_output)
+
+    @property
+    def _identifying_params(self) -> Mapping[str, Any]:
+        """Get the identifying parameters."""
+        return {**{'model_name': self.model_name}, **self._default_params}
+
+    @property
+    def _client_params(self) -> Mapping[str, Any]:
+        """Get the parameters used for the openai client."""
+        zhipu_creds: Dict[str, Any] = {
+            'access_key_id': self.access_key_id,
+            'secret_access_key': self.secret_access_key,
+            'model': self.model_name,
+        }
+        return {**zhipu_creds, **self._default_params}
+
+    def _get_invocation_params(self,
+                               stop: Optional[List[str]] = None,
+                               **kwargs: Any) -> Dict[str, Any]:
+        """Get the parameters used to invoke the model FOR THE CALLBACKS."""
+        return {
+            **super()._get_invocation_params(stop=stop, **kwargs),
+            **self._default_params,
+            'model': self.model_name,
+            'function': kwargs.get('functions'),
+        }
+
+    @property
+    def _llm_type(self) -> str:
+        """Return type of chat model."""
+        return 'sense-chat'

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.3.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.3
+Version: 0.2.2.5
 Summary: bisheng langchain modules
 Home-page: https://github.com/dataelement/bisheng
 Author: DataElem

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

@@ -8,27 +8,30 @@ bisheng_langchain/agents/chatglm_functions_agent/prompt.py,sha256=OiBTRUOhvhSyO2
 bisheng_langchain/agents/llm_functions_agent/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 bisheng_langchain/agents/llm_functions_agent/base.py,sha256=_bJNSYZJrY82Tcc0zwQLO4qyuTZbOkVDBA0hndGM12w,12311
 bisheng_langchain/autogen_role/__init__.py,sha256=MnTGbAOK770JM9l95Qcxu93s2gNAmhlil7K9HdFG81o,430
-bisheng_langchain/autogen_role/assistant.py,sha256=6gA36zaolvV0MA35kPbdkbdsmmRiH3mGk7I_2P5Bm_g,4170
-bisheng_langchain/autogen_role/custom.py,sha256=WiHK0vTIP0vMDhtKPNR4-A950i0qwLlowJO0v-g0d40,2423
-bisheng_langchain/autogen_role/groupchat_manager.py,sha256=L53RmXyv4QMVuw1zGoXRe8hB2s39DVUEb_zASWoO_yI,1746
-bisheng_langchain/autogen_role/user.py,sha256=hBZsCIBG_LLWEOma7GzsUMjl896KSMjtu9J8gFOq2P4,5207
-bisheng_langchain/chains/__init__.py,sha256=QWryJz0vlTAFAFrzQW672hvrNXjV3Hr4oJyg92UPlM4,551
+bisheng_langchain/autogen_role/assistant.py,sha256=VGCoxJaRxRG6ZIJa2TsxcLZbMbF4KC8PRB76DOuznNU,4736
+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=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=A3_KoMRp96UqHwwYX4Mt60peVNjCsuUHAixqaV44BP4,492
-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=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
@@ -45,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
@@ -69,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.3.dist-info/METADATA,sha256=9UgVujQ3Ep2eBWGmbeoe8r-dPNqOjPxXHa0_WYSz7pw,2299
-bisheng_langchain-0.2.2.3.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-bisheng_langchain-0.2.2.3.dist-info/top_level.txt,sha256=Z6pPNyCo4ihyr9iqGQbH8sJiC4dAUwA_mAyGRQB5_Fs,18
-bisheng_langchain-0.2.2.3.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,,