bisheng-langchain 0.2.3.2__py3-none-any.whl → 0.3.0__py3-none-any.whl

bisheng_langchain/gpts/tools/api_tools/tianyancha.py

@@ -0,0 +1,160 @@
+"""tianyancha api"""
+from __future__ import annotations
+
+from typing import Any, Dict, Type
+
+from bisheng_langchain.utils.requests import Requests, RequestsWrapper
+from langchain_core.pydantic_v1 import BaseModel, Field, root_validator
+
+from .base import APIToolBase
+
+
+class InputArgs(BaseModel):
+    """args_schema"""
+    query: str = Field(description='搜索关键字（公司名称、公司id、注册号或社会统一信用代码）')
+
+
+class CompanyInfo(APIToolBase):
+    """Manage tianyancha company client."""
+    api_key: str = None
+    args_schema: Type[BaseModel] = InputArgs
+
+    @root_validator(pre=True)
+    def build_header(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+        """Build headers that were passed in."""
+        if not values.get('api_key'):
+            raise ValueError('Parameters api_key should be specified give.')
+
+        headers = values.get('headers', {})
+        headers.update({'Authorization': values['api_key']})
+        values['headers'] = headers
+        return values
+
+    @root_validator()
+    def validate_environment(cls, values: Dict) -> Dict:
+        """Validate that api key and python package exists in environment."""
+        timeout = values.get('request_timeout', 30)
+        if not values.get('client'):
+            values['client'] = Requests(headers=values['headers'], request_timeout=timeout)
+        if not values.get('async_client'):
+            values['async_client'] = RequestsWrapper(headers=values['headers'],
+                                                     request_timeout=timeout)
+        return values
+
+    @classmethod
+    def search_company(cls, api_key: str, pageNum: int = 1, pageSize: int = 20) -> CompanyInfo:
+        """可以通过关键词获取企业列表，企业列表包括公司名称或ID、类型、成立日期、经营状态、统一社会信用代码等字段的详细信息"""
+        url = 'http://open.api.tianyancha.com/services/open/search/2.0'
+        input_key = 'word'
+        params = {}
+        params['pageSize'] = pageSize
+        params['pageNum'] = pageNum
+
+        return cls(url=url, api_key=api_key, input_key=input_key, params=params)
+
+    @classmethod
+    def get_company_baseinfo(cls, api_key: str) -> CompanyInfo:
+        """可以通过公司名称或ID获取企业基本信息，企业基本信息包括公司名称或ID、类型、成立日期、经营状态、注册资本、法人、工商注册号、统一社会信用代码、组织机构代码、纳税人识别号等字段信息"""
+        url = 'http://open.api.tianyancha.com/services/open/ic/baseinfo/normal'
+        input_key = 'keyword'
+        params = {}
+
+        return cls(url=url, api_key=api_key, input_key=input_key, params=params)
+
+    @classmethod
+    def ip_rights(cls, api_key: str) -> CompanyInfo:
+        """可以通过公司名称或ID获取包含商标、专利、作品著作权、软件著作权、网站备案等维度的相关信息"""
+        url = 'http://open.api.tianyancha.com/services/open/cb/ipr/3.0'
+        input_key = 'keyword'
+
+        return cls(url=url, api_key=api_key, input_key=input_key, params={})
+
+    @classmethod
+    def judicial_risk(cls, api_key: str) -> CompanyInfo:
+        """可以通过公司名称或ID获取包含法律诉讼、法院公告、开庭公告、失信人、被执行人、立案信息、送达公告等维度的相关信息"""
+        url = 'http://open.api.tianyancha.com/services/open/cb/judicial/2.0'
+        return cls(url=url, api_key=api_key)
+
+    @classmethod
+    def ic_info(cls, api_key: str) -> CompanyInfo:
+        """可以通过公司名称或ID获取包含企业基本信息、主要人员、股东信息、对外投资、分支机构等维度的相关信息"""
+        url = 'http://open.api.tianyancha.com/services/open/cb/ic/2.0'
+
+        return cls(url=url, api_key=api_key)
+
+    @classmethod
+    def law_suit_case(cls, api_key: str, pageSize: int = 20, pageNum: int = 1) -> CompanyInfo:
+        """可以通过公司名称或ID获取企业法律诉讼信息，法律诉讼包括案件名称、案由、案件身份、案号等字段的详细信息"""
+        url = 'http://open.api.tianyancha.com/services/open/jr/lawSuit/3.0'
+        params = {}
+        params['pageSize'] = pageSize
+        params['pageNum'] = pageNum
+        return cls(url=url, api_key=api_key, params=params)
+
+    @classmethod
+    def company_change_info(cls,
+                            api_key: str,
+                            pageSize: int = 20,
+                            pageNum: int = 1) -> CompanyInfo:
+        """可以通过公司名称或ID获取企业变更记录，变更记录包括工商变更事项、变更前后信息等字段的详细信息"""
+        url = 'http://open.api.tianyancha.com/services/open/ic/changeinfo/2.0'
+        params = {}
+        params['pageSize'] = pageSize
+        params['pageNum'] = pageNum
+        return cls(url=url, api_key=api_key, params=params)
+
+    @classmethod
+    def company_holders(cls, api_key: str, pageSize: int = 20, pageNum: int = 1) -> CompanyInfo:
+        """可以通过公司名称或ID获取企业股东信息，股东信息包括股东名、出资比例、出资金额、股东总数等字段的详细信息"""
+        url = 'http://open.api.tianyancha.com/services/open/ic/holder/2.0'
+        params = {}
+        params['pageSize'] = pageSize
+        params['pageNum'] = pageNum
+        return cls(url=url, api_key=api_key, params=params)
+
+    @classmethod
+    def all_companys_by_company(cls, api_key: str, pageSize: int = 20, pageNum: int = 1):
+        """可以通过公司名称获取企业人员的所有相关公司，包括其担任法人、股东、董监高的公司信息"""
+        url = 'http://open.api.tianyancha.com/services/v4/open/allCompanys'
+        input_key = 'name'
+        params = {}
+        params['pageSize'] = pageSize
+        params['pageNum'] = pageNum
+
+        class InputArgs(BaseModel):
+            """args_schema"""
+            query: str = Field(description='company name to query')
+
+        return cls(url=url,
+                   api_key=api_key,
+                   params=params,
+                   input_key=input_key,
+                   args_schema=InputArgs)
+
+    @classmethod
+    def all_companys_by_humanname(cls,
+                                  api_key: str,
+                                  pageSize: int = 20,
+                                  pageNum: int = 1) -> CompanyInfo:
+        """可以通过人名获取企业人员的所有相关公司，包括其担任法人、股东、董监高的公司信息"""
+        url = 'http://open.api.tianyancha.com/services/v4/open/allCompanys'
+        input_key = 'humanName'
+        params = {}
+        params['pageSize'] = pageSize
+        params['pageNum'] = pageNum
+
+        class InputArgs(BaseModel):
+            """args_schema"""
+            query: str = Field(description='human name to query')
+
+        return cls(url=url,
+                   api_key=api_key,
+                   params=params,
+                   input_key=input_key,
+                   args_schema=InputArgs)
+
+    @classmethod
+    def riskinfo(cls, api_key: str) -> CompanyInfo:
+        """可以通过关键字（公司名称、公司id、注册号或社会统一信用代码）获取企业相关天眼风险列表，包括企业自身/周边/预警风险信息。"""
+        url = 'http://open.api.tianyancha.com/services/open/risk/riskInfo/2.0'
+        return cls(url=url, api_key=api_key)

bisheng_langchain/gpts/tools/bing_search/tool.py

@@ -0,0 +1,55 @@
+"""Tool for the Bing search API."""
+
+from typing import Optional, Type
+
+from langchain.pydantic_v1 import BaseModel, Field
+from langchain_community.utilities.bing_search import BingSearchAPIWrapper
+from langchain_core.callbacks import CallbackManagerForToolRun
+from langchain_core.tools import BaseTool
+
+
+class BingSearchInput(BaseModel):
+    query: str = Field(description="query to look up in Bing search")
+
+
+class BingSearchRun(BaseTool):
+    """Tool that queries the Bing search API."""
+
+    name: str = "bing_search"
+    description: str = (
+        "A wrapper around Bing Search. "
+        "Useful for when you need to answer questions about current events. "
+        "Input should be a search query."
+    )
+    args_schema: Type[BaseModel] = BingSearchInput
+    api_wrapper: BingSearchAPIWrapper
+
+    def _run(
+        self,
+        query: str,
+        run_manager: Optional[CallbackManagerForToolRun] = None,
+    ) -> str:
+        """Use the tool."""
+        return self.api_wrapper.run(query)
+
+
+class BingSearchResults(BaseTool):
+    """Tool that queries the Bing Search API and gets back json."""
+
+    name: str = "bing_search_results_json"
+    description: str = (
+        "A wrapper around Bing Search. "
+        "Useful for when you need to answer questions about current events. "
+        "Input should be a search query. Output is a JSON array of the query results"
+    )
+    num_results: int = 4
+    args_schema = BingSearchInput
+    api_wrapper: BingSearchAPIWrapper
+
+    def _run(
+        self,
+        query: str,
+        run_manager: Optional[CallbackManagerForToolRun] = None,
+    ) -> str:
+        """Use the tool."""
+        return str(self.api_wrapper.results(query, self.num_results))

bisheng_langchain/gpts/tools/calculator/tool.py

@@ -0,0 +1,25 @@
+import math
+from math import *
+
+import sympy
+from langchain.pydantic_v1 import BaseModel, Field
+from langchain.tools import tool
+from sympy import *
+
+
+class CalculatorInput(BaseModel):
+    expression: str = Field(
+        description="The input to this tool should be a mathematical expression using only Python's built-in mathematical operators.",
+        example='200*7',
+    )
+
+
+@tool("calculator", args_schema=CalculatorInput)
+def calculator(expression):
+    """Useful to perform any mathematical calculations,
+    like sum, minus, multiplication, division, etc
+    """
+    try:
+        return eval(expression)
+    except SyntaxError:
+        return "Error: Invalid syntax in mathematical expression"

bisheng_langchain/gpts/tools/code_interpreter/tool.py

@@ -0,0 +1,261 @@
+import itertools
+import os
+import pathlib
+import subprocess
+import sys
+import tempfile
+from concurrent.futures import ThreadPoolExecutor, TimeoutError
+from datetime import timedelta
+from hashlib import md5
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple, Type
+from uuid import uuid4
+
+from autogen.code_utils import extract_code, infer_lang
+from langchain_community.tools import Tool
+from langchain_core.pydantic_v1 import BaseModel, Field
+from loguru import logger
+
+try:
+    from termcolor import colored
+except ImportError:
+
+    def colored(x, *args, **kwargs):
+        return x
+
+
+DEFAULT_TIMEOUT = 600
+WIN32 = sys.platform == 'win32'
+PATH_SEPARATOR = WIN32 and '\\' or '/'
+WORKING_DIR = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'extensions')
+TIMEOUT_MSG = 'Timeout'
+
+
+def _cmd(lang):
+    if lang.startswith('python') or lang in ['bash', 'sh', 'powershell']:
+        return lang
+    if lang in ['shell']:
+        return 'sh'
+    if lang in ['ps1']:
+        return 'powershell'
+    raise NotImplementedError(f'{lang} not recognized in code execution')
+
+
+def execute_code(
+    code: Optional[str] = None,
+    timeout: Optional[int] = None,
+    filename: Optional[str] = None,
+    work_dir: Optional[str] = None,
+    lang: Optional[str] = 'python',
+) -> Tuple[int, str, str]:
+    if all((code is None, filename is None)):
+        error_msg = f'Either {code=} or {filename=} must be provided.'
+        logger.error(error_msg)
+        raise AssertionError(error_msg)
+
+    timeout = timeout or DEFAULT_TIMEOUT
+    original_filename = filename
+
+    if filename is None:
+        code_hash = md5(code.encode()).hexdigest()
+        # create a file with a automatically generated name
+        filename = f"tmp_code_{code_hash}.{'py' if lang.startswith('python') else lang}"
+    if work_dir is None:
+        work_dir = WORKING_DIR
+    filepath = os.path.join(work_dir, filename)
+    file_dir = os.path.dirname(filepath)
+    os.makedirs(file_dir, exist_ok=True)
+    (Path(file_dir) / 'output').mkdir(exist_ok=True, parents=True)
+    if code is not None:
+        with open(filepath, 'w', encoding='utf-8') as fout:
+            fout.write(code)
+
+    cmd = [
+        sys.executable if lang.startswith('python') else _cmd(lang),
+        f'.\\{filename}' if WIN32 else filename,
+    ]
+    if WIN32:
+        logger.warning('SIGALRM is not supported on Windows. No timeout will be enforced.')
+        result = subprocess.run(
+            cmd,
+            cwd=work_dir,
+            capture_output=True,
+            text=True,
+        )
+    else:
+        with ThreadPoolExecutor(max_workers=1) as executor:
+            future = executor.submit(
+                subprocess.run,
+                cmd,
+                cwd=work_dir,
+                capture_output=True,
+                text=True,
+            )
+            try:
+                result = future.result(timeout=timeout)
+            except TimeoutError:
+                if original_filename is None:
+                    os.remove(filepath)
+                return 1, TIMEOUT_MSG, None
+    if original_filename is None:
+        os.remove(filepath)
+    if result.returncode:
+        logs = result.stderr
+        if original_filename is None:
+            abs_path = str(pathlib.Path(filepath).absolute())
+            logs = logs.replace(str(abs_path), '').replace(filename, '')
+        else:
+            abs_path = str(pathlib.Path(work_dir).absolute()) + PATH_SEPARATOR
+            logs = logs.replace(str(abs_path), '')
+    else:
+        logs = result.stdout
+    return result.returncode, logs, None
+
+
+def head_file(path: str, n: int) -> List[str]:
+    """Get the first n lines of a file."""
+    try:
+        with open(path, 'r') as f:
+            return [str(line) for line in itertools.islice(f, n)]
+    except Exception:
+        return []
+
+
+def upload_minio(param: dict, bucket: str, object_name: str, file_path, content_type='application/text'):
+    # 初始化minio
+    import minio
+
+    minio_client = minio.Minio(**param)
+    logger.debug('upload_file obj={} bucket={} file_paht={}', object_name, bucket, file_path)
+    minio_client.fput_object(
+        bucket_name=bucket, object_name=object_name, file_path=file_path, content_type=content_type
+    )
+    return minio_client.presigned_get_object(bucket_name=bucket, object_name=object_name, expires=timedelta(days=7))
+
+
+class CodeInterpreterToolArguments(BaseModel):
+    """Arguments for the BearlyInterpreterTool."""
+
+    python_code: str = Field(
+        ...,
+        example="print('Hello World')",
+        description=(
+            'The pure python script to be evaluated. '
+            'The contents will be in main.py. '
+            'It should not be in markdown format.'
+        ),
+    )
+
+
+base_description = """Evaluates python code in native environment. \
+You must send the whole script every time and print your outputs. \
+Script should be pure python code that can be evaluated. \
+It should be in python format NOT markdown. \
+The code should NOT be wrapped in backticks. \
+If you have any files outputted write them to "output/" relative to the execution \
+path. Output can only be read from the directory, stdout, and stdin. \
+Do not use things like plot.show() as it will \
+not work instead write them out `output/`\
+print() any output and results so you can capture the output."""  # noqa: T201
+
+
+class FileInfo(BaseModel):
+    """Information about a file to be uploaded."""
+
+    source_path: str
+    description: str
+
+
+class CodeInterpreterTool:
+    """Tool for evaluating python code in native environment."""
+
+    name = 'code_interpreter'
+    args_schema: Type[BaseModel] = CodeInterpreterToolArguments
+
+    def __init__(
+        self,
+        minio: Dict[str, any],
+        files: Dict[str, FileInfo] = None,
+    ) -> None:
+        self.minio = minio
+        self.files = files if files else {}
+
+    @property
+    def file_description(self) -> str:
+        if not len(self.files) or not isinstance(self.files, dict):
+            return ''
+        lines = ['The following files available in the evaluation environment:']
+        for source_path, file_info in self.files.items():
+            peek_content = head_file(file_info.source_path, 4)
+            lines.append(
+                f'- path: `{file_info.source_path}` \n first four lines: {peek_content}'
+                f' \n description: `{file_info.description}`'
+            )
+        return '\n'.join(lines)
+
+    @property
+    def description(self) -> str:
+        return (base_description + '\n\n' + self.file_description).strip()
+
+    def _run(self, code_string: str) -> dict:
+        code_blocks = extract_code(code_string)
+        logs_all = ''
+        file_list = []
+        for i, code_block in enumerate(code_blocks):
+            lang, code = code_block
+            lang = infer_lang(code)
+            temp_dir = tempfile.TemporaryDirectory()
+            exitcode, logs, _ = execute_code(
+                code,
+                work_dir=temp_dir.name,
+                lang=lang,
+            )
+            logs_all += '\n' + logs
+            if exitcode != 0:
+                return {'exitcode': exitcode, 'log': logs_all}
+
+            # 获取文件
+            temp_output_dir = Path(temp_dir.name) / 'output'
+            for root, dirs, files in os.walk(temp_output_dir):
+                for name in files:
+                    file_name = os.path.join(root, name)
+                    if self.minio:
+                        file_type = file_name.rsplit('.', 1)[-1]
+                        object_name = uuid4().hex
+                        file_list.append(upload_minio(self.minio, 'bisheng', f'{object_name}.{file_type}', file_name))
+                    else:
+                        file_list.append(file_name)
+            temp_dir.cleanup()
+
+        return {'exitcode': 0, 'log': logs_all, 'file_list': file_list}
+
+    def as_tool(self) -> Tool:
+        return Tool.from_function(
+            func=self._run,
+            name=self.name,
+            description=self.description,
+            args_schema=self.args_schema,
+        )
+
+
+if __name__ == '__main__':
+    code_string = """print('hha')"""
+    code_blocks = extract_code(code_string)
+    logger.info(code_blocks)
+    logs_all = ''
+    for i, code_block in enumerate(code_blocks):
+        lang, code = code_block
+        lang = infer_lang(code)
+        print(
+            colored(
+                f'\n>>>>>>>> EXECUTING CODE BLOCK {i} (inferred language is {lang})...',
+                'red',
+            ),
+            flush=True,
+        )
+        exitcode, logs, image = execute_code(code, lang=lang)
+        logs_all += '\n' + logs
+        if exitcode != 0:
+            logger.error(f'{exitcode}, {logs_all}')
+
+    logger.info(logs_all)