bisheng-langchain 0.1.10.1__py3-none-any.whl → 0.2.0rc0__py3-none-any.whl

bisheng_langchain/chains/__init__.py

@@ -1,6 +1,9 @@
 from bisheng_langchain.chains.autogen.auto_gen import AutoGenChain
 from bisheng_langchain.chains.combine_documents.stuff import StuffDocumentsChain
+from bisheng_langchain.chains.router.multi_rule import MultiRuleChain
+from bisheng_langchain.chains.router.rule_router import RuleBasedRouter
 
 from .loader_output import LoaderOutputChain
 
-__all__ = ['StuffDocumentsChain', 'LoaderOutputChain', 'AutoGenChain']
+__all__ = ['StuffDocumentsChain', 'LoaderOutputChain', 'AutoGenChain',
+           'RuleBasedRouter', 'MultiRuleChain']

bisheng_langchain/chains/router/multi_rule.py

@@ -0,0 +1,14 @@
+from typing import List, Mapping
+
+from langchain.chains.router.base import Chain, MultiRouteChain, RouterChain
+
+
+class MultiRuleChain(MultiRouteChain):
+    router_chain: RouterChain
+    destination_chains: Mapping[str, Chain]
+    default_chain: Chain
+    output_variables: List[str]
+
+    @property
+    def output_keys(self) -> List[str]:
+        return self.output_variables

bisheng_langchain/chains/router/rule_router.py

@@ -0,0 +1,47 @@
+from typing import Any, Callable, Dict, List, Union
+
+from langchain.callbacks.manager import Callbacks
+from langchain.chains.router.base import Route, RouterChain
+
+
+class RuleBasedRouter(RouterChain):
+    rule_function: Callable[..., str]
+    input_variables: List[str]
+
+    @property
+    def input_keys(self):
+        return self.input_variables
+
+    def _validate_outputs(self, outputs: Dict[str, Any]) -> None:
+        super()._validate_outputs(outputs)
+        if not isinstance(outputs['next_inputs'], dict):
+            raise ValueError
+
+    def _call(
+        self,
+        inputs: Union[Dict[str, Any], Any],
+    ) -> Route:
+        result = self.rule_function(inputs)
+        if not result.get('destination') or not result:
+            return Route(None, result['next_inputs'])
+        return Route(result['destination'], result['next_inputs'])
+
+    def route(
+        self,
+        inputs: Union[Dict[str, Any], Any],
+        callbacks: Callbacks = None,
+    ) -> Route:
+        result = self.rule_function(inputs)
+        if not result.get('destination') or not result:
+            return Route(None, result['next_inputs'])
+        return Route(result['destination'], result['next_inputs'])
+
+    async def aroute(
+        self,
+        inputs: Union[Dict[str, Any], Any],
+        callbacks: Callbacks = None,
+    ) -> Route:
+        result = await self.rule_function(inputs)
+        if not result.get('destination') or not result:
+            return Route(None, result['next_inputs'])
+        return Route(result['destination'], result['next_inputs'])

bisheng_langchain/chat_models/host_llm.py

@@ -379,7 +379,7 @@ class HostQwenChat(BaseHostChatLLM):
     model_name: str = Field('Qwen-7B-Chat', alias='model')
 
     temperature: float = 0
-    top_p: float = 0.5
+    top_p: float = 1
     max_tokens: int = 8192
 
     @property

bisheng_langchain/chat_models/proxy_llm.py

@@ -194,10 +194,14 @@ class ProxyChatLLM(BaseChatModel):
                 'function_call': kwargs.get('function_call', None),
                 'functions': kwargs.get('functions', [])
             }
-            response = self.client.post(self.elemai_base_url, data=params)
+            response = self.client.post(self.elemai_base_url, json=params)
             return response.json()
 
-        return _completion_with_retry(**kwargs)
+        rsp_dict = _completion_with_retry(**kwargs)
+        if 200 != rsp_dict.get('status_code'):
+            logger.error(f"proxy_llm_error resp={rsp_dict}")
+            raise Exception(rsp_dict)
+        return rsp_dict
 
     def _combine_llm_outputs(self, llm_outputs: List[Optional[dict]]) -> dict:
         overall_token_usage: dict = {}
@@ -233,7 +237,7 @@ class ProxyChatLLM(BaseChatModel):
         @retry_decorator
         async def _acompletion_with_retry(**kwargs: Any) -> Any:
             # Use OpenAI's async api https://github.com/openai/openai-python#async-api
-            async with self.client.apost(url=self.elemai_base_url, data=kwargs) as response:
+            async with self.client.apost(url=self.elemai_base_url, json=kwargs) as response:
                 async for txt in response.content.iter_any():
                     if b'\n' in txt:
                         for txt_ in txt.split(b'\n'):

bisheng_langchain/document_loaders/__init__.py

@@ -1,3 +1,4 @@
+from .custom_kv import CustomKVLoader
 from .elem_pdf import PDFWithSemanticLoader
 from .elem_unstrcutured_loader import ElemUnstructuredLoader, ElemUnstructuredLoaderV0
 from .universal_kv import UniversalKVLoader
@@ -7,4 +8,5 @@ __all__ = [
     'ElemUnstructuredLoader',
     'ElemUnstructuredLoaderV0',
     'UniversalKVLoader',
+    'CustomKVLoader',
 ]

bisheng_langchain/document_loaders/custom_kv.py

@@ -0,0 +1,166 @@
+# flake8: noqa
+"""Loads PDF with semantic splilter."""
+import base64
+import json
+import logging
+import os
+import re
+import tempfile
+from pathlib import Path
+from time import sleep
+from typing import List, Optional, Tuple, Union
+from urllib.parse import quote_plus, unquote, urlparse
+
+import cv2
+import fitz
+import numpy as np
+from bisheng_langchain.utils.requests import Requests
+from langchain.docstore.document import Document
+from langchain.document_loaders.base import BaseLoader
+from PIL import Image
+
+logger = logging.getLogger(__name__)
+
+def convert_base64(image):
+    image_binary = cv2.imencode('.jpg', image)[1].tobytes()
+    x = base64.b64encode(image_binary)
+    return x.decode('ascii').replace('\n', '')
+
+
+def transpdf2png(pdf_file):
+    pdf_bytes = open(pdf_file, 'rb').read()
+    pdf = fitz.Document(stream=pdf_bytes, filetype='pdf')
+    dpis = [72, 144, 200]
+
+    pdf_images = dict()
+    for page in pdf:
+        pix = None
+        for dpi in dpis:
+            pix = page.get_pixmap(dpi=dpi)
+            if min(pix.width, pix.height) >= 1600: break
+
+        mode = 'RGBA' if pix.alpha else 'RGB'
+        img = Image.frombytes(mode, [pix.width, pix.height], pix.samples)
+        # RGB to BGR
+        img = np.array(img)[:, :, ::-1]
+        img_name = 'page_{:03d}'.format(page.number)
+        pdf_images[img_name] = img
+
+    return pdf_images
+
+
+class CustomKVLoader(BaseLoader):
+    """Extract key-value from pdf or image.
+    """
+    def __init__(self, file_path:str,
+                 elm_api_base_url: str,
+                 elm_api_key: str,
+                 schemas: str,
+                 elem_server_id: str,
+                 task_type: str,
+                 request_timeout: Optional[Union[float, Tuple[float, float]]] = 30) -> None:
+        """Initialize with a file path."""
+        self.file_path = file_path
+        self.elm_api_base_url = elm_api_base_url
+        self.elm_api_key = elm_api_key
+        self.elem_server_id = elem_server_id
+        self.task_type = task_type
+        self.schemas = set(schemas.split('|'))
+        self.headers = {'Authorization': f'Bearer {elm_api_key}'}
+        self.requests = Requests(headers=self.headers,
+                                 request_timeout=request_timeout)
+        if '~' in self.file_path:
+            self.file_path = os.path.expanduser(self.file_path)
+
+        # If the file is a web path, download it to a temporary file, and use that
+        if not os.path.isfile(self.file_path) and self._is_valid_url(self.file_path):
+            r = self.requests.get(self.file_path)
+
+            if r.status_code != 200:
+                raise ValueError(
+                    'Check the url of your file; returned status code %s'
+                    % r.status_code
+                )
+
+            self.temp_dir = tempfile.TemporaryDirectory()
+            temp_file = Path(self.temp_dir.name) / unquote(urlparse(self.file_path
+                                                                    ).path.split('/')[-1])
+            with open(temp_file, mode='wb') as f:
+                f.write(r.content)
+            self.file_path = str(temp_file)
+        elif not os.path.isfile(self.file_path):
+            raise ValueError('File path %s is not a valid file or url' % self.file_path)
+        super().__init__()
+
+    @staticmethod
+    def _is_valid_url(url: str) -> bool:
+        """Check if the url is valid."""
+        parsed = urlparse(url)
+        return bool(parsed.netloc) and bool(parsed.scheme)
+
+    def load(self) -> List[Document]:
+        """Load given path as pages."""
+        # mime_type = filetype.guess(self.file_path).mime
+        # if mime_type.endswith('pdf'):
+        #     file_type = 'pdf'
+        # elif mime_type.startswith('image'):
+        #     file_type = 'img'
+
+        # else:
+        #     raise ValueError(f'file type {file_type} is not support.')
+        file = {'file': open(self.file_path, 'rb')}
+        result = {}
+        if self.task_type == 'extraction-job':
+            url = self.elm_api_base_url + '/task'
+            # 创建task
+            body = {'scene_id': self.elem_server_id}
+        elif self.task_type == 'logic-job':
+            url = self.elm_api_base_url + '/logic-job'
+            body = {'logic_service_id': self.elem_server_id}
+
+        resp = self.requests.post(url=url, json={}, data=body, files=file)
+        if resp.status_code == 200:
+            task_id = resp.json().get('data').get('task_id')
+            if not task_id:
+                logger.error(f'task_create_fail res={resp.text}')
+                return
+            # get status
+            status_url = url + f'/status?task_id={task_id}'
+            count = 0
+            while True:
+                status = self.requests.get(status_url).json()
+                if 1 == status.get('data').get('status'):
+                    count += 1
+                    sleep(2)
+                elif 3 == status.get('data').get('status'):
+                    # 失败
+                    logger.error(f'custom_kv type={self.task_type} resp={status}')
+                    return []
+                else:
+                    break
+            # get result
+            job_id = 'job_id' if self.task_type == 'logic-job' else 'task_id'
+            match = re.match(r'^(?:https?:\/\/)?(?:www\.)?([^\/\n]+)', self.elm_api_base_url)
+            detail_url = quote_plus(match.group()+f'/logic-job-detail/{task_id}')
+            result_url = url + f'/result?{job_id}={task_id}&detail_url={detail_url}'
+            result = self.requests.get(result_url).json()
+            # only for independent key
+            document_result = {}
+            try:
+                result = self.requests.get(result_url).json()
+                file_reuslt = result.get('data')
+                for result in file_reuslt:
+                    independent = result.get('result').get('independent_list')
+                    for element in independent:
+                        if element.get('element_name') in self.schemas:
+                            document_result[element.get('element_name')] = [el.get('words')
+                                                                    for el in element.get('entity_list')]
+            except Exception as e:
+                logger.error(f'task_result_error scene_id={self.elem_server_id} res={result} except={str(e)}')
+                raise Exception('custom_kv parse_error')
+        else:
+            logger.error(f'custom_kv=create_task resp={resp.text}')
+            raise Exception('custom_kv create task file')
+        content = json.dumps(document_result)
+        doc = Document(page_content=content)
+        return [doc]

bisheng_langchain/document_loaders/elem_unstrcutured_loader.py

@@ -1,31 +1,15 @@
 # flake8: noqa
 """Loads PDF with semantic splilter."""
 import base64
-import io
-import json
 import logging
 import os
-import re
-import tempfile
-import time
-from abc import ABC
-from collections import Counter
-from copy import deepcopy
-from pathlib import Path
-from typing import Any, Iterator, List, Mapping, Optional, Union
-from urllib.parse import urlparse
-
-import fitz
-import numpy as np
-import pypdfium2
+from typing import List
+
 import requests
-from bisheng_langchain.document_loaders.parsers import LayoutParser
 from langchain.docstore.document import Document
-from langchain.document_loaders.blob_loaders import Blob
 from langchain.document_loaders.pdf import BasePDFLoader
-from shapely import Polygon
-from shapely import box as Rect
 
+logger = logging.getLogger(__name__)
 
 def merge_partitions(partitions):
     text_elem_sep = '\n'
@@ -112,9 +96,7 @@ class ElemUnstructuredLoader(BasePDFLoader):
 
 
 class ElemUnstructuredLoaderV0(BasePDFLoader):
-    """Loads a PDF with pypdf and chunks at character level. dummy version
-
-    Loader also stores page numbers in metadata.
+    """The appropriate parser is automatically selected based on the file format and OCR is supported
     """
     def __init__(self,
                  file_name : str,
@@ -143,6 +125,9 @@ class ElemUnstructuredLoaderV0(BasePDFLoader):
             headers=self.headers,
             json=payload).json()
 
+        if 200!=resp.get('status_code'):
+            logger.info(f'not return resp={resp}')
+
         page_content = resp['text']
         meta = {'source': self.file_name}
         doc = Document(page_content=page_content, metadata=meta)

bisheng_langchain/document_loaders/universal_kv.py

@@ -1,30 +1,19 @@
 # flake8: noqa
 """Loads PDF with semantic splilter."""
 import base64
-import io
 import json
-import logging
 import os
-import re
-import tempfile
-import time
-import filetype
-import cv2
 from collections import defaultdict
-from abc import ABC
-from collections import Counter
-from copy import deepcopy
-from pathlib import Path
-from typing import Any, Iterator, List, Mapping, Optional, Union
-from urllib.parse import urlparse
-from PIL import Image
+from typing import List
 
+import cv2
+import filetype
 import fitz
 import numpy as np
-import requests
+from bisheng_langchain.document_loaders.parsers import ELLMClient
 from langchain.docstore.document import Document
 from langchain.document_loaders.base import BaseLoader
-from bisheng_langchain.document_loaders.parsers import ELLMClient, OCRClient
+from PIL import Image
 
 
 def convert_base64(image):
@@ -45,11 +34,11 @@ def transpdf2png(pdf_file):
             pix = page.get_pixmap(dpi=dpi)
             if min(pix.width, pix.height) >= 1600: break
 
-        mode = "RGBA" if pix.alpha else "RGB"
+        mode = 'RGBA' if pix.alpha else 'RGB'
         img = Image.frombytes(mode, [pix.width, pix.height], pix.samples)
         # RGB to BGR
         img = np.array(img)[:, :, ::-1]
-        img_name = "page_{:03d}".format(page.number)
+        img_name = 'page_{:03d}'.format(page.number)
         pdf_images[img_name] = img
 
     return pdf_images
@@ -79,7 +68,7 @@ class UniversalKVLoader(BaseLoader):
         elif mime_type.startswith('image'):
             file_type = 'img'
         else:
-            raise ValueError(f"file type {file_type} is not support.")
+            raise ValueError(f'file type {file_type} is not support.')
 
         if file_type == 'img':
             bytes_data = open(self.file_path, 'rb').read()
@@ -90,7 +79,7 @@ class UniversalKVLoader(BaseLoader):
             if 'code' in resp and resp['code'] == 200:
                 key_values = resp['result']['ellm_result']
             else:
-                raise ValueError(f"universal kv load failed: {resp}")
+                raise ValueError(f'universal kv load failed: {resp}')
 
             kv_results = defaultdict(list)
             for key, value in key_values.items():
@@ -118,7 +107,7 @@ class UniversalKVLoader(BaseLoader):
                 if 'code' in resp and resp['code'] == 200:
                     key_values = resp['result']['ellm_result']
                 else:
-                    raise ValueError(f"universal kv load failed: {resp}")
+                    raise ValueError(f'universal kv load failed: {resp}')
 
                 for key, value in key_values.items():
                     kv_results[key].extend(value['text'])
@@ -128,4 +117,3 @@ class UniversalKVLoader(BaseLoader):
             meta = {'source': file_name}
             doc = Document(page_content=content, metadata=meta)
             return [doc]
-

bisheng_langchain/input_output/__init__.py

@@ -0,0 +1,4 @@
+from .input import InputFileNode, InputNode, VariableNode
+from .output import Report
+
+__all__ = ['InputNode', 'InputFileNode', 'Report', 'VariableNode']

bisheng_langchain/input_output/input.py

@@ -1,23 +1,48 @@
 
-from typing import List
+from typing import List, Optional
 
 from pydantic import BaseModel, Extra
 
 
-class Variable(BaseModel):
+class InputNode(BaseModel):
+    """Input组件，用来控制输入"""
+    input: Optional[List[str]]
+
+    def text(self):
+        return self.input
+
+
+class VariableNode(BaseModel):
     """用来设置变量"""
-    variable_name: str
-    variable_key: str
+    # key
+    variables: Optional[List[str]]
+    # vaulues
+    variable_value: Optional[List[str]] = []
 
     class Config:
         """Configuration for this pydantic object."""
 
         extra = Extra.forbid
 
-    @classmethod
-    def initialize(cls, input: List[str] = None):
-        return input if input else ''
+    def text(self):
+        if self.variable_value:
+            text = {}
+            for index, value in enumerate(self.variable_value):
+                text[self.variables[index]] = value
+
+            return text
+        else:
+            return {}
+
 
+class InputFileNode(BaseModel):
+    file_path: Optional[str]
+    file_name: Optional[str]
+    file_type: Optional[str]  # tips for file
+    """Output组件，用来控制输出"""
 
-class PresetQuestion(BaseModel):
-    pass
+    def text(self):
+        # judge if file_path is oss address
+        if not self.file_path:
+            return ''
+        return [self.file_path, self.file_name]

bisheng_langchain/input_output/output.py

@@ -0,0 +1,276 @@
+import json
+from typing import Any, Dict, List, Optional
+from venv import logger
+
+from bisheng_langchain.chains import LoaderOutputChain
+from langchain.callbacks.manager import AsyncCallbackManagerForChainRun, CallbackManagerForChainRun
+from langchain.chains.base import Chain
+from pydantic import BaseModel, Extra
+
+_TEXT_COLOR_MAPPING = {
+    'blue': '36;1',
+    'yellow': '33;1',
+    'pink': '38;5;200',
+    'green': '32;1',
+    'red': '31;1',
+}
+
+
+def get_color_mapping(
+    items: List[str], excluded_colors: Optional[List] = None
+) -> Dict[str, str]:
+    """Get mapping for items to a support color."""
+    colors = list(_TEXT_COLOR_MAPPING.keys())
+    if excluded_colors is not None:
+        colors = [c for c in colors if c not in excluded_colors]
+    color_mapping = {item: colors[i % len(colors)] for i, item in enumerate(items)}
+    return color_mapping
+
+
+class Output(BaseModel):
+    """Output组件，用来控制输出"""
+
+    @classmethod
+    def initialize(cls, file_path: str = None):
+        return file_path if file_path else ''
+
+
+class Report(Chain):
+    # ```
+    # chain Dict:
+    #    object: langchain_object
+    #    node_id: object_key prefix
+    #    input: triger query
+    # variables Dict:
+    #    variable_name: name
+    #    variable_value: value
+    # `
+    chains: Optional[List[Dict]]
+    variables: Optional[List[Dict]]
+    report_name: str
+    stop_flag: bool = False
+
+    input_key: str = 'report_name'  #: :meta private:
+    output_key: str = 'text'  #: :meta private:
+
+    class Config:
+        """Configuration for this pydantic object."""
+        extra = Extra.forbid
+        arbitrary_types_allowed = True
+
+    @property
+    def input_keys(self) -> List[str]:
+        """Expect input key.
+        :meta private:
+        """
+        return [self.input_key]
+
+    @property
+    def output_keys(self) -> List[str]:
+        """Return output key.
+        :meta private:
+        """
+        return [self.output_key]
+
+    def validate_chains(cls, values: Dict) -> Dict:
+        """Validate chains."""
+        if values.get('chains'):
+            for chain in values['chains']:
+                chain_output_keys = chain['object'].output_keys
+                if len(chain_output_keys) != 1:
+                    raise ValueError(
+                        'Chain used in Report should all have one output, got '
+                        f"{chain['object']} with {len(chain_output_keys)} outputs."
+                    )
+            return values
+
+    def func_call(self,
+                  inputs: Dict[str, Any],
+                  outputs: Dict[str, Any],
+                  intermedia_stop: list,
+                  chain: Chain,
+                  node_id: str,
+                  run_manager: Optional[CallbackManagerForChainRun] = None,):
+        question = list(inputs.values())[0]
+        _run_manager = run_manager or CallbackManagerForChainRun.get_noop_manager()
+
+        if isinstance(chain, LoaderOutputChain):
+            question = 'Get' + ','.join(question)
+        _run_manager.on_text(text='', log='', type='start', category='question')
+        _run_manager.on_text(text='', log=question, type='end', category='question')
+        _run_manager.on_text(text='', log='', type='start', category='answer')
+        message_reply = {'log': question, 'category': 'question'}
+        intermedia_stop.append(message_reply)
+
+        chain_outputs = chain(inputs, callbacks=_run_manager.get_child())
+        result = (chain_outputs.get(chain.output_keys[0])
+                  if isinstance(chain_outputs, dict) else chain_outputs)
+        if isinstance(chain, LoaderOutputChain):
+            for schema in inputs.values():
+                result = json.loads(result)
+                for key in schema:
+                    if result.get(key):
+                        result_str = ('；'.join([str(x) for x in result.get(key)])
+                                      if isinstance(result.get(key), list)
+                                      else result.get(key))
+                        outputs.update({node_id+'_'+key: result_str})
+            result = json.dumps(result, ensure_ascii=False)
+        else:
+            outputs.update({node_id: result})
+        message_reply = {'log': result, 'category': 'answer'}
+        intermedia_stop.append(message_reply)
+        _run_manager.on_text(text='', log=result, type='end', category='answer')
+
+    async def func_acall(self,
+                         inputs: Dict[str, Any],
+                         outputs: Dict[str, Any],
+                         intermedia_stop: list,
+                         chain: Chain,
+                         node_id: str,
+                         run_manager: Optional[AsyncCallbackManagerForChainRun] = None,):
+        question = list(inputs.values())[0]
+        _run_manager = run_manager or AsyncCallbackManagerForChainRun.get_noop_manager()
+
+        if isinstance(chain, LoaderOutputChain):
+            question = 'Get' + ','.join(question)
+        await _run_manager.on_text(text='', log='', type='start', category='question')
+        await _run_manager.on_text(text='', log=question, type='end', category='question')
+        await _run_manager.on_text(text='', log='', type='start', category='answer')
+        message_reply = {'log': question, 'category': 'question'}
+        intermedia_stop.append(message_reply)
+
+        # process
+        try:
+            chain_outputs = await chain.arun(inputs, callbacks=_run_manager.get_child())
+        except Exception as e:
+            logger.exception(e)
+            await _run_manager.on_text(text='', log=str(e), type='stream', category='processing')
+            try:
+                chain_outputs = chain(inputs)
+            except Exception as e2:
+                logger.exception(e2)
+                await _run_manager.on_text(text='', log=str(e2), type='stream', category='processing')
+                chain_outputs = ''
+
+        result = (chain_outputs.get(chain.output_keys[0])
+                  if isinstance(chain_outputs, dict) else chain_outputs)
+        if isinstance(chain, LoaderOutputChain):
+            for schema in inputs.values():
+                result = json.loads(result)
+                for key in schema:
+                    if result.get(key):
+                        result_str = ('；'.join([str(x) for x in result.get(key)])
+                                      if isinstance(result.get(key), list)
+                                      else result.get(key))
+                        outputs.update({node_id+'_'+key: result_str})
+            result = json.dumps(result, ensure_ascii=False)
+        else:
+            outputs.update({node_id: result})
+        message_reply = {'log': result, 'category': 'answer'}
+        intermedia_stop.append(message_reply)
+        await _run_manager.on_text(text='', log=result, type='end', category='answer')
+
+    def _call(
+        self,
+        inputs: Dict[str, Any],
+        run_manager: Optional[CallbackManagerForChainRun] = None,
+        verbose: Optional[bool] = None,
+    ) -> Dict[str, str]:
+        intermedia_steps = []
+        outputs = {}
+        self.stop_flag = False
+        # variables
+        if self.variables and self.variables[0]:
+            for variable in self.variables:
+                variable_kv = variable['input']
+                for k, v in variable_kv.items():
+                    outputs.update({variable['node_id']+'_'+k: v})
+
+        if self.chains:
+            for i, chain in enumerate(self.chains):
+                if 'node_id' not in chain:
+                    logger.info(f"report_skip_nonsence_chain chain={chain['object']}")
+                    continue
+                if not isinstance(chain['object'], Chain):
+                    raise TypeError(
+                        f"{chain['object']} not be runnable Chain object"
+                    )
+                if isinstance(chain['object'], LoaderOutputChain):
+                    # loaderchain questions use new parse
+                    self.func_call(chain['input'], outputs, intermedia_steps,
+                                   chain['object'], chain['node_id'], run_manager)
+                    continue
+
+                preset_question = chain['input']
+                for k, v in preset_question.items():
+                    # log print
+                    if isinstance(v, str):
+                        self.func_call(preset_question, outputs, intermedia_steps,
+                                       chain['object'], chain['node_id']+'_'+v, run_manager)
+                    else:
+                        for question in v:
+                            question_dict = {k: question}
+                            self.func_call(question_dict, outputs, intermedia_steps,
+                                           chain['object'], chain['node_id']+'_'+question,
+                                           run_manager)
+
+        return {self.output_key: outputs, self.input_key: self.report_name,
+                'intermediate_steps': intermedia_steps}
+
+    async def _acall(
+        self,
+        inputs: Dict[str, Any],
+        run_manager: Optional[AsyncCallbackManagerForChainRun] = None,
+        verbose: Optional[bool] = None,
+    ) -> Dict[str, Any]:
+        intermedia_steps = []
+        outputs = {}
+        await run_manager.on_text(text='', log='', type='end', category='processing')  # end father start
+        self.stop_flag = False
+        # variables
+        if self.variables and self.variables[0]:
+            for variable in self.variables:
+                variable_kv = variable['input']
+                for k, v in variable_kv.items():
+                    outputs.update({variable['node_id']+'_'+k: v})
+
+        # functions
+        if self.chains:
+            for i, chain in enumerate(self.chains):
+                if 'node_id' not in chain:
+                    logger.info(f"report_skip_nonsence_chain chain={chain['object']}")
+                    continue
+                if self.stop_flag:
+                    break
+                if not isinstance(chain['object'], Chain):
+                    raise TypeError(
+                        f"{chain['object']} not be runnable Chain object"
+                    )
+                if isinstance(chain['object'], LoaderOutputChain):
+                    # loaderchain questions use new parse
+                    await self.func_acall(chain['input'], outputs, intermedia_steps,
+                                          chain['object'], chain['node_id'], run_manager)
+                    continue
+                # normal chain
+                preset_question = chain['input']
+                for k, v in preset_question.items():
+                    if isinstance(v, str):
+                        await self.func_acall(preset_question, outputs, intermedia_steps,
+                                              chain['object'], chain['node_id']+'_'+v, run_manager)
+                    else:
+                        for question in v:
+                            question_dict = {k: question}
+                            await self.func_acall(question_dict, outputs, intermedia_steps,
+                                                  chain['object'], chain['node_id']+'_'+question,
+                                                  run_manager)
+
+        # keep whole process paired
+        await run_manager.on_text(text='', log='', type='start', category='processing')
+        return {self.output_key: outputs, self.input_key: self.report_name,
+                'intermediate_steps': intermedia_steps}
+
+    def stop(self):
+        self.stop_flag = True
+
+    def stop_status(self):
+        return self.stop_flag

bisheng_langchain/utils/requests.py

@@ -33,28 +33,28 @@ class Requests(BaseModel):
                             timeout=self.request_timeout,
                             **kwargs)
 
-    def post(self, url: str, data: Dict[str, Any], **kwargs: Any) -> requests.Response:
+    def post(self, url: str, json: Dict[str, Any], **kwargs: Any) -> requests.Response:
         """POST to the URL and return the text."""
         return requests.post(url,
-                             json=data,
+                             json=json,
                              headers=self.headers,
                              auth=self.auth,
                              timeout=self.request_timeout,
                              **kwargs)
 
-    def patch(self, url: str, data: Dict[str, Any], **kwargs: Any) -> requests.Response:
+    def patch(self, url: str, json: Dict[str, Any], **kwargs: Any) -> requests.Response:
         """PATCH the URL and return the text."""
         return requests.patch(url,
-                              json=data,
+                              json=json,
                               headers=self.headers,
                               auth=self.auth,
                               timeout=self.request_timeout,
                               **kwargs)
 
-    def put(self, url: str, data: Dict[str, Any], **kwargs: Any) -> requests.Response:
+    def put(self, url: str, json: Dict[str, Any], **kwargs: Any) -> requests.Response:
         """PUT the URL and return the text."""
         return requests.put(url,
-                            json=data,
+                            json=json,
                             headers=self.headers,
                             auth=self.auth,
                             timeout=self.request_timeout,
@@ -98,24 +98,24 @@ class Requests(BaseModel):
             yield response
 
     @asynccontextmanager
-    async def apost(self, url: str, data: Dict[str, Any],
+    async def apost(self, url: str, json: Dict[str, Any],
                     **kwargs: Any) -> AsyncGenerator[aiohttp.ClientResponse, None]:
         """POST to the URL and return the text asynchronously."""
-        async with self._arequest('POST', url, json=data, auth=self.auth, **kwargs) as response:
+        async with self._arequest('POST', url, json=json, auth=self.auth, **kwargs) as response:
             yield response
 
     @asynccontextmanager
-    async def apatch(self, url: str, data: Dict[str, Any],
+    async def apatch(self, url: str, json: Dict[str, Any],
                      **kwargs: Any) -> AsyncGenerator[aiohttp.ClientResponse, None]:
         """PATCH the URL and return the text asynchronously."""
-        async with self._arequest('PATCH', url, json=data, auth=self.auth, **kwargs) as response:
+        async with self._arequest('PATCH', url, json=json, auth=self.auth, **kwargs) as response:
             yield response
 
     @asynccontextmanager
-    async def aput(self, url: str, data: Dict[str, Any],
+    async def aput(self, url: str, json: Dict[str, Any],
                    **kwargs: Any) -> AsyncGenerator[aiohttp.ClientResponse, None]:
         """PUT the URL and return the text asynchronously."""
-        async with self._arequest('PUT', url, json=data, auth=self.auth, **kwargs) as response:
+        async with self._arequest('PUT', url, json=json, auth=self.auth, **kwargs) as response:
             yield response
 
     @asynccontextmanager
@@ -150,17 +150,17 @@ class TextRequestsWrapper(BaseModel):
         """GET the URL and return the text."""
         return self.requests.get(url, **kwargs).text
 
-    def post(self, url: str, data: Dict[str, Any], **kwargs: Any) -> str:
+    def post(self, url: str, json: Dict[str, Any], **kwargs: Any) -> str:
         """POST to the URL and return the text."""
-        return self.requests.post(url, data, **kwargs).text
+        return self.requests.post(url, json, **kwargs).text
 
-    def patch(self, url: str, data: Dict[str, Any], **kwargs: Any) -> str:
+    def patch(self, url: str, json: Dict[str, Any], **kwargs: Any) -> str:
         """PATCH the URL and return the text."""
-        return self.requests.patch(url, data, **kwargs).text
+        return self.requests.patch(url, json, **kwargs).text
 
-    def put(self, url: str, data: Dict[str, Any], **kwargs: Any) -> str:
+    def put(self, url: str, json: Dict[str, Any], **kwargs: Any) -> str:
         """PUT the URL and return the text."""
-        return self.requests.put(url, data, **kwargs).text
+        return self.requests.put(url, json, **kwargs).text
 
     def delete(self, url: str, **kwargs: Any) -> str:
         """DELETE the URL and return the text."""
@@ -171,19 +171,19 @@ class TextRequestsWrapper(BaseModel):
         async with self.requests.aget(url, **kwargs) as response:
             return await response.text()
 
-    async def apost(self, url: str, data: Dict[str, Any], **kwargs: Any) -> str:
+    async def apost(self, url: str, json: Dict[str, Any], **kwargs: Any) -> str:
         """POST to the URL and return the text asynchronously."""
-        async with self.requests.apost(url, data, **kwargs) as response:
+        async with self.requests.apost(url, json, **kwargs) as response:
             return await response.text()
 
-    async def apatch(self, url: str, data: Dict[str, Any], **kwargs: Any) -> str:
+    async def apatch(self, url: str, json: Dict[str, Any], **kwargs: Any) -> str:
         """PATCH the URL and return the text asynchronously."""
-        async with self.requests.apatch(url, data, **kwargs) as response:
+        async with self.requests.apatch(url, json, **kwargs) as response:
             return await response.text()
 
-    async def aput(self, url: str, data: Dict[str, Any], **kwargs: Any) -> str:
+    async def aput(self, url: str, json: Dict[str, Any], **kwargs: Any) -> str:
         """PUT the URL and return the text asynchronously."""
-        async with self.requests.aput(url, data, **kwargs) as response:
+        async with self.requests.aput(url, json, **kwargs) as response:
             return await response.text()
 
     async def adelete(self, url: str, **kwargs: Any) -> str:

bisheng_langchain/vectorstores/__init__.py

@@ -1,3 +1,4 @@
 from .elastic_keywords_search import ElasticKeywordsSearch
+from .retriever import VectorStoreFilterRetriever
 
-__all__ = ['ElasticKeywordsSearch']
+__all__ = ['ElasticKeywordsSearch', 'VectorStoreFilterRetriever']

bisheng_langchain/vectorstores/retriever.py

@@ -0,0 +1,111 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, ClassVar, Collection, Dict, List
+from venv import logger
+
+import requests
+from langchain.schema.document import Document
+from langchain.vectorstores.base import VectorStore, VectorStoreRetriever
+from pydantic import Field, root_validator
+
+if TYPE_CHECKING:
+    from langchain.callbacks.manager import (
+        AsyncCallbackManagerForRetrieverRun,
+        CallbackManagerForRetrieverRun,
+    )
+
+
+class VectorStoreFilterRetriever(VectorStoreRetriever):
+    vectorstore: VectorStore
+    search_type: str = 'similarity'
+    search_kwargs: dict = Field(default_factory=dict)
+    allowed_search_types: ClassVar[Collection[str]] = (
+        'similarity',
+        'similarity_score_threshold',
+        'mmr',
+    )
+    access_url: str = None
+
+    class Config:
+        """Configuration for this pydantic object."""
+
+        arbitrary_types_allowed = True
+
+    @root_validator()
+    def validate_search_type(cls, values: Dict) -> Dict:
+        """Validate search type."""
+        search_type = values['search_type']
+        if search_type not in cls.allowed_search_types:
+            raise ValueError(
+                f'search_type of {search_type} not allowed. Valid values are: '
+                f'{cls.allowed_search_types}'
+            )
+        if search_type == 'similarity_score_threshold':
+            score_threshold = values['search_kwargs'].get('score_threshold')
+            if (score_threshold is None) or (not isinstance(score_threshold, float)):
+                raise ValueError(
+                    '`score_threshold` is not specified with a float value(0~1) '
+                    'in `search_kwargs`.'
+                )
+        return values
+
+    def _get_relevant_documents(
+        self, query: str, *, run_manager: CallbackManagerForRetrieverRun
+    ) -> List[Document]:
+        if self.search_type == 'similarity':
+            docs = self.vectorstore.similarity_search(query, **self.search_kwargs)
+        elif self.search_type == 'similarity_score_threshold':
+            docs_and_similarities = (
+                self.vectorstore.similarity_search_with_relevance_scores(
+                    query, **self.search_kwargs
+                )
+            )
+            docs = [doc for doc, _ in docs_and_similarities]
+        elif self.search_type == 'mmr':
+            docs = self.vectorstore.max_marginal_relevance_search(
+                query, **self.search_kwargs
+            )
+        else:
+            raise ValueError(f'search_type of {self.search_type} not allowed.')
+
+        return self.get_file_access(docs)
+
+    async def _aget_relevant_documents(
+        self, query: str, *, run_manager: AsyncCallbackManagerForRetrieverRun
+    ) -> List[Document]:
+        if self.search_type == 'similarity':
+            docs = await self.vectorstore.asimilarity_search(
+                query, **self.search_kwargs
+            )
+        elif self.search_type == 'similarity_score_threshold':
+            docs_and_similarities = (
+                await self.vectorstore.asimilarity_search_with_relevance_scores(
+                    query, **self.search_kwargs
+                )
+            )
+            docs = [doc for doc, _ in docs_and_similarities]
+        elif self.search_type == 'mmr':
+            docs = await self.vectorstore.amax_marginal_relevance_search(
+                query, **self.search_kwargs
+            )
+        else:
+            raise ValueError(f'search_type of {self.search_type} not allowed.')
+        return self.get_file_access(docs)
+
+    def get_file_access(self, docs: List[Document]):
+        file_ids = [doc.metadata.get('file_id') for doc in docs]
+        if file_ids:
+            res = requests.get(self.access_url, json=file_ids)
+            if res.status_code == 200:
+                doc_res = res.json().get('data')
+                doc_right = {doc.get('docid') for doc in doc_res if doc.get('result') == 1}
+                for doc in docs:
+                    if doc.metadata.get('file_id') not in doc_right:
+                        doc.page_content = ''
+                        doc.metadata['right'] = False
+                return docs
+            else:
+                logger.error(f'query_file_access_fail url={self.access_url} res={res.text}')
+                return [Document(page_content='', metadata={})]
+        else:
+            return docs

{bisheng_langchain-0.1.10.1.dist-info → bisheng_langchain-0.2.0rc0.dist-info}/METADATA

@@ -1,12 +1,11 @@
 Metadata-Version: 2.1
 Name: bisheng-langchain
-Version: 0.1.10.1
+Version: 0.2.0rc0
 Summary: bisheng langchain modules
 Home-page: https://github.com/dataelement/bisheng
 Author: DataElem
 Author-email: contact@dataelem.com
 License: Apache 2.0
-Platform: UNKNOWN
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.6
 Classifier: Programming Language :: Python :: 3.7
@@ -20,8 +19,8 @@ Requires-Dist: langchain
 Requires-Dist: zhipuai
 Requires-Dist: websocket-client
 Requires-Dist: elasticsearch
-Requires-Dist: opencv-python ==4.5.5.64
-Requires-Dist: Pillow ==9.5.0
+Requires-Dist: opencv-python (==4.5.5.64)
+Requires-Dist: Pillow (==9.5.0)
 Requires-Dist: bisheng-pyautogen
 
 ## What is bisheng-langchain?
@@ -65,5 +64,3 @@ check out [bisheng-langchain Dev Docs](https://dataelem.feishu.cn/wiki/Xaq8wKQjk
 bisheng-langchain adopts dependencies from the following:
 
 - Thanks to [langchain](https://github.com/langchain-ai/langchain) for the main framework.
-
-

{bisheng_langchain-0.1.10.1.dist-info → bisheng_langchain-0.2.0rc0.dist-info}/RECORD

@@ -5,17 +5,20 @@ bisheng_langchain/autogen_role/assistant.py,sha256=6gA36zaolvV0MA35kPbdkbdsmmRiH
 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=Hwp2bu5_GJPMjZJnMLePxBtl7nizOCW0KtKPyu49DQ0,4953
-bisheng_langchain/chains/__init__.py,sha256=uba9Igpyk83fEp4bWYSWOAlwS-U5RABNLQv8H8ZugWU,266
+bisheng_langchain/chains/__init__.py,sha256=zd1FQGN0G5b_52oibBbdHsny0Y4T36YQnj6j1tRd4zQ,456
 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/question_answering/__init__.py,sha256=RWbSgTQ0IqZhrXkhaJUKzEXurA9NJE7_6P0zLy0IBjs,8636
+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=QWLKqJ9ZCQb9E3oh6pd0C6YZRhHyoJSmDFkx31LNpME,1563
 bisheng_langchain/chat_models/__init__.py,sha256=FBNhc-zwFtPmWdNlt0QgzgOx2hVT-He1yOzgKZEBYQE,463
-bisheng_langchain/chat_models/host_llm.py,sha256=HgxWx3AmwwRlvXLimh4ZT1C8C_xAnOMadywqqUJ_gHU,16995
+bisheng_langchain/chat_models/host_llm.py,sha256=UV-u3XaIQsw1Qz8XCJuADxWd7m8Xpey5fQdnOtEpIgo,16993
 bisheng_langchain/chat_models/minimax.py,sha256=VFq1U4Ax1ZPFrsxzxilRE6NXvUH0HEoK1vDq5kXADTU,13963
-bisheng_langchain/chat_models/proxy_llm.py,sha256=oIH8sGZTK4bklRaSwvIcPCPtAlPdhxSBZqfp7cNmYWo,16463
+bisheng_langchain/chat_models/proxy_llm.py,sha256=JdxQq7QJjHwmuZ7QsTaZawkWzDESZohKstiwMoqrPDY,16637
 bisheng_langchain/chat_models/wenxin.py,sha256=GRhFFqToVpYwbHz9NQrH4lvVlOQ_9rtQEl6uikgNH_w,13793
 bisheng_langchain/chat_models/xunfeiai.py,sha256=GP30oqpbb8UAxrkJ2l0anDq67Q40CUNulg9nu7PtQZc,14019
 bisheng_langchain/chat_models/zhipuai.py,sha256=v29bsAZoe_5KR2LQVoKE7429U4Qc3FqcZIgAm8p2aX4,14941
@@ -27,12 +30,13 @@ bisheng_langchain/chat_models/interface/utils.py,sha256=qww_uYsWDqK7cLuv-KzZmmlg
 bisheng_langchain/chat_models/interface/wenxin.py,sha256=z_K1Nj78dDYYgiVIzc5sGkOiGr8OAoRwaKwmpWXssH0,4246
 bisheng_langchain/chat_models/interface/xunfei.py,sha256=DPHAZM_uHg0A8GnebgkRbLENhBW7bBtRHzKC0gFKZgc,7514
 bisheng_langchain/chat_models/interface/zhipuai.py,sha256=67Ej6DRk-IlXUfEZPg-pjcYPyqZb32ClrBP-9k-3EEs,2636
-bisheng_langchain/document_loaders/__init__.py,sha256=lkLjlw6zyOu_ekObVYw8O95Z27ZwXu49PvowYWgK4mQ,306
+bisheng_langchain/document_loaders/__init__.py,sha256=LuQ-zMYxde2FeiEcvVtjQqnHozki5pF_pDDa88_fBdg,366
+bisheng_langchain/document_loaders/custom_kv.py,sha256=1xGir73LcH6lfIyzy4HX-Rg5bjbd_MWJPpqKDkf29CI,6623
 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=64kUITkrTVJe9CH6IAVSdDVcn2Ekx2PM-jT0cdClXlo,22716
-bisheng_langchain/document_loaders/elem_unstrcutured_loader.py,sha256=5r1O4h3uM4EV7OQ8E8-H3wNUoYIVtFNIT5HGT1tz-z8,4980
-bisheng_langchain/document_loaders/universal_kv.py,sha256=RA5OMGZcBCfCrArE8fNuAh6wa4xGwnaXgRj4ebHM9HU,4332
+bisheng_langchain/document_loaders/elem_unstrcutured_loader.py,sha256=qLqDTYA7IRguI0OiQ6PY3HzQCiQnc76Qy3_QHf90BMs,4616
+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
 bisheng_langchain/document_loaders/parsers/image.py,sha256=7Vx4dD_WiSTojS4TMIJFxfE8nvze0kwNnwTd6f1cLds,938
@@ -44,16 +48,18 @@ bisheng_langchain/embeddings/wenxin.py,sha256=8kYqWuHydx5Cylb_Lmdti0YLHrOM1Qha3e
 bisheng_langchain/embeddings/interface/__init__.py,sha256=GNY3tibpRxpAdAfSvQmXBKo0xKSLke_9y4clofi_WOE,98
 bisheng_langchain/embeddings/interface/types.py,sha256=VdurbtsnjCPdlOjPFcK2Mg6r9bJYYHb3tepvkk-y3nM,461
 bisheng_langchain/embeddings/interface/wenxin.py,sha256=5d9gI4enmfkD80s0FHKiDt33O0mwM8Xc5WTubnMUy8c,3104
-bisheng_langchain/input_output/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-bisheng_langchain/input_output/input.py,sha256=Na2-DLeLym6Phuh8RIQk8N-xWcFEiRzHkhyeKD429cg,420
-bisheng_langchain/input_output/output.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bisheng_langchain/input_output/__init__.py,sha256=sW_GB7MlrHYsqY1Meb_LeimQqNsMz1gH-00Tqb2BUyM,153
+bisheng_langchain/input_output/input.py,sha256=I5YDmgbvvj1o2lO9wi8LE37wM0wP5jkhUREU32YrZMQ,1094
+bisheng_langchain/input_output/output.py,sha256=6U-az6-Cwz665C2YmcH3SYctWVjPFjmW8s70CA_qphk,11585
 bisheng_langchain/retrievers/__init__.py,sha256=TcyK31IMgFJcYaOCLd9O6qFzXt1VMbtLs-g4C6ml_3w,117
 bisheng_langchain/retrievers/mix_es_vector.py,sha256=-V1IGQJZMar2a35FrXf5MaHV_R8TpYdF8r1jIR-JDjA,3973
 bisheng_langchain/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-bisheng_langchain/utils/requests.py,sha256=WmlHmV6pw5InxXSKNiIVc1kvcwt28CJadA6EY6XgrqA,8397
-bisheng_langchain/vectorstores/__init__.py,sha256=K3xQouSGl05Q0ehFCKZafip-35NzCrv8SCANvfxDpKE,96
+bisheng_langchain/utils/requests.py,sha256=abZvV6-p3cyJpFtFzcvzCUGRYh17Bjdy2BRElG7zPL4,8397
+bisheng_langchain/vectorstores/__init__.py,sha256=3xXjqJj_DwgQcQUC1MpPrYYhSKeg4yk67OtzmVAjco0,176
 bisheng_langchain/vectorstores/elastic_keywords_search.py,sha256=UU3yJoSSH-prBJtoWQR8dYQzrSOLSvVBRdU45QtE7KA,11648
-bisheng_langchain-0.1.10.1.dist-info/METADATA,sha256=1PnMWVLeB95JJ7x20O4FyWPlNiytyisujisMIIEqH_E,2141
-bisheng_langchain-0.1.10.1.dist-info/WHEEL,sha256=Xo9-1PvkuimrydujYJAjF7pCkriuXBpUPEjma1nZyJ0,92
-bisheng_langchain-0.1.10.1.dist-info/top_level.txt,sha256=Z6pPNyCo4ihyr9iqGQbH8sJiC4dAUwA_mAyGRQB5_Fs,18
-bisheng_langchain-0.1.10.1.dist-info/RECORD,,
+bisheng_langchain/vectorstores/milvus.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bisheng_langchain/vectorstores/retriever.py,sha256=wq__1xRN3PfAgU8Kh8Am8iEsUkkVuJnhWTY6GFDAADg,4365
+bisheng_langchain-0.2.0rc0.dist-info/METADATA,sha256=6KiZWWBaZ9hv4pkDlbXM-62q5gA65O3onYng4EHl4Ek,2125
+bisheng_langchain-0.2.0rc0.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
+bisheng_langchain-0.2.0rc0.dist-info/top_level.txt,sha256=Z6pPNyCo4ihyr9iqGQbH8sJiC4dAUwA_mAyGRQB5_Fs,18
+bisheng_langchain-0.2.0rc0.dist-info/RECORD,,

{bisheng_langchain-0.1.10.1.dist-info → bisheng_langchain-0.2.0rc0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.41.3)
+Generator: bdist_wheel (0.38.4)
 Root-Is-Purelib: true
 Tag: py3-none-any