adam-community 0.2__tar.gz

adam_community-0.2/PKG-INFO

@@ -0,0 +1,53 @@
+Metadata-Version: 2.4
+Name: adam_community
+Version: 0.2
+Summary: Adam Community Tools and Utilities
+Home-page: https://github.com/yourusername/adam-community
+Author: Adam Community
+Author-email: admin@sidereus-ai.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.31.0
+Requires-Dist: click>=8.0.0
+Requires-Dist: docstring-parser>=0.15
+Requires-Dist: rich>=13.0.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Adam Community
+
+Adam Community 是一个 Python 工具包，提供了一系列实用工具和功能，用于与 Adam 社区相关的开发工作。
+
+安装依赖：
+```bash
+make install
+```
+
+
+## 使用方法
+
+安装完成后，您可以在 Python 代码中导入并使用该包：
+
+```python
+from adam_community import tool
+from adam_community import util
+
+# 使用相关功能
+```
+
+## 开发
+
+运行测试：
+```bash
+make test
+```

adam_community-0.2/README.md

@@ -0,0 +1,27 @@
+# Adam Community
+
+Adam Community 是一个 Python 工具包，提供了一系列实用工具和功能，用于与 Adam 社区相关的开发工作。
+
+安装依赖：
+```bash
+make install
+```
+
+
+## 使用方法
+
+安装完成后，您可以在 Python 代码中导入并使用该包：
+
+```python
+from adam_community import tool
+from adam_community import util
+
+# 使用相关功能
+```
+
+## 开发
+
+运行测试：
+```bash
+make test
+```

adam_community-0.2/adam_community/__init__.py

@@ -0,0 +1,4 @@
+from .util import messageSend, knowledgeSearch, completionCreate, runCmd
+from .tool import Tool
+
+__all__ = ['Tool', 'messageSend', 'knowledgeSearch', 'completionCreate', 'runCmd']

adam_community-0.2/adam_community/cli/build.py

@@ -0,0 +1,236 @@
+import json
+import zipfile
+from pathlib import Path
+from typing import Tuple, List
+from rich.console import Console
+from rich.panel import Panel
+from rich.tree import Tree
+from .parser import parse_directory
+
+console = Console()
+
+def check_python_files(directory: Path) -> Tuple[bool, List[str]]:
+    """检查所有 Python 文件是否都有参数定义"""
+    tree = Tree("📦 Python 文件检查")
+    errors = []
+    functions = parse_directory(directory)
+    
+    tree.add(f"找到 {len(functions)} 个类定义")
+    for func in functions:
+        func_info = func["function"]
+        if not func_info["description"]:
+            tree.add(f"⚠️ {func_info['file']}: {func_info['name']} 没有描述")
+
+        if not func_info["parameters"]["properties"]:
+            tree.add(f"⚠️ {func_info['file']}: {func_info['name']} 没有参数定义")
+        else:
+            tree.add(f"✓ {func_info['file']}: {func_info['name']}")
+    
+    if errors:
+        tree.add("❌ 检查未通过")
+    else:
+        tree.add("✅ 检查通过")
+    
+    console.print(tree)
+    return len(errors) == 0, errors
+
+def check_configuration(directory: Path) -> Tuple[bool, List[str]]:
+    """检查 configure.json 文件"""
+    tree = Tree("📄 配置文件检查")
+    errors = []
+    config_path = directory / "config" / "configure.json"
+    
+    if not config_path.exists():
+        tree.add("❌ 未找到 configure.json 文件")
+        console.print(tree)
+        return False, ["configure.json 文件不存在"]
+    
+    try:
+        with open(config_path, 'r', encoding='utf-8') as f:
+            config = json.load(f)
+        
+        required_fields = ["name", "version", "display_name"]
+        for field in required_fields:
+            if field not in config:
+                errors.append(f"configure.json 缺少必要字段: {field}")
+                tree.add(f"❌ 缺少字段: {field}")
+            else:
+                tree.add(f"✓ {field}: {config[field]}")
+        
+        if errors:
+            tree.add("❌ 检查未通过")
+        else:
+            tree.add("✅ 检查通过")
+        
+        console.print(tree)
+        return len(errors) == 0, errors
+    except json.JSONDecodeError:
+        tree.add("❌ 配置文件格式错误")
+        console.print(tree)
+        return False, ["configure.json 文件格式错误"]
+
+def check_markdown_files(directory: Path) -> Tuple[bool, List[str]]:
+    """检查必要的 Markdown 文件"""
+    tree = Tree("📑 Markdown 文件检查")
+    errors = []
+    
+    # 先读取配置文件中的 type 字段
+    config_path = directory / "config" / "configure.json"
+    config_type = "agent"  # 默认值
+    
+    if config_path.exists():
+        try:
+            with open(config_path, 'r', encoding='utf-8') as f:
+                config = json.load(f)
+                config_type = config.get("type", "agent")
+        except json.JSONDecodeError:
+            pass  # 配置文件格式错误时使用默认值
+    
+    # 根据 type 设置不同的 required_files
+    if config_type == "kit":
+        required_files = [
+            "configure.json", 
+            "long_description.md",
+            "input.json"
+        ]
+    else:  # type=agent 或空值
+        required_files = [
+            "initial_assistant_message.md",
+            "initial_system_prompt.md", 
+            "long_description.md"
+        ]
+    
+    tree.add(f"检查类型: {config_type}")
+    
+    for file in required_files:
+        file_path = directory / "config" / file
+        if not file_path.exists():
+            errors.append(f"缺少必要文件: {file}")
+            tree.add(f"❌ {file}")
+        else:
+            # 对于 input.json，额外检查 JSON 格式
+            if file == "input.json":
+                try:
+                    with open(file_path, 'r', encoding='utf-8') as f:
+                        json.load(f)
+                    tree.add(f"✓ {file} (JSON 格式正确)")
+                except json.JSONDecodeError:
+                    errors.append(f"{file} JSON 格式错误")
+                    tree.add(f"❌ {file} (JSON 格式错误)")
+            else:
+                tree.add(f"✓ {file}")
+    
+    if errors:
+        tree.add("❌ 检查未通过")
+    else:
+        tree.add("✅ 检查通过")
+    
+    console.print(tree)
+    return len(errors) == 0, errors
+
+def create_zip_package(directory: Path) -> str:
+    """创建 zip 包"""
+    tree = Tree("📦 创建压缩包")
+    with open(directory / "config" / "configure.json", 'r', encoding='utf-8') as f:
+        config = json.load(f)
+    
+    zip_name = f"{config['name']}_{config['version']}.zip"
+    zip_path = directory / zip_name
+    
+    tree.add(f"包名: {zip_name}")
+    
+    # 获取配置类型
+    config_type = config.get("type", "agent")
+    
+    with zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_DEFLATED) as zipf:
+        # 添加所有 Python 文件
+        py_files = list(directory.rglob('*.py'))
+        py_tree = tree.add("Python 文件")
+        for py_file in py_files:
+            if not py_file.name.startswith('_'):
+                zipf.write(py_file, py_file.relative_to(directory))
+                py_tree.add(f"+ {py_file.relative_to(directory)}")
+        
+        # 添加配置文件
+        config_tree = tree.add("配置文件")
+        zipf.write(directory / "config" / "configure.json", "config/configure.json")
+        config_tree.add("+ config/configure.json")
+        
+        # 添加 demos 目录
+        demos_tree = tree.add("Demos 文件")
+        demos_dir = directory / "demos"
+        if demos_dir.exists() and demos_dir.is_dir():
+            for demos_file in demos_dir.rglob('*'):
+                if demos_file.is_file():
+                    zipf.write(demos_file, demos_file.relative_to(directory))
+                    demos_tree.add(f"+ {demos_file.relative_to(directory)}")
+        
+        # 根据类型添加不同的文件
+        md_tree = tree.add("其他文件")
+        if config_type == "kit":
+            # kit 类型需要添加的文件
+            other_files = ["long_description.md", "input.json"]
+        else:
+            # agent 类型需要添加的文件
+            other_files = ["initial_assistant_message.md", "initial_system_prompt.md", "long_description.md"]
+        
+        for file in other_files:
+            file_path = directory / "config" / file
+            if file_path.exists():
+                zipf.write(file_path, f"config/{file}")
+                md_tree.add(f"+ config/{file}")
+    
+    tree.add("✅ 压缩包创建完成")
+    console.print(tree)
+    return zip_name
+
+def build_package(directory: Path) -> Tuple[bool, List[str], str]:
+    """构建项目包
+    
+    Returns:
+        Tuple[bool, List[str], str]: (是否成功, 错误信息列表, zip包名称)
+    """
+    console.print(Panel.fit(
+        "[bold blue]🚀 开始构建项目包[/bold blue]",
+        border_style="blue"
+    ))
+    
+    all_passed = True
+    all_errors = []
+    
+    # 1. 检查 Python 文件
+    py_passed, py_errors = check_python_files(directory)
+    if not py_passed:
+        all_passed = False
+        all_errors.extend(py_errors)
+    
+    # 2. 检查配置文件
+    config_passed, config_errors = check_configuration(directory)
+    if not config_passed:
+        all_passed = False
+        all_errors.extend(config_errors)
+    
+    # 3. 检查 Markdown 文件
+    md_passed, md_errors = check_markdown_files(directory)
+    if not md_passed:
+        all_passed = False
+        all_errors.extend(md_errors)
+    
+    # 如果所有检查都通过，创建 zip 包
+    zip_name = ""
+    if all_passed:
+        zip_name = create_zip_package(directory)
+    
+    if all_passed:
+        console.print(Panel.fit(
+            f"[bold green]✅ 构建成功！[/bold green]\n"
+            f"压缩包: {zip_name}",
+            border_style="green"
+        ))
+    else:
+        console.print(Panel.fit(
+            "[bold red]❌ 构建失败！[/bold red]\n" + "\n".join(all_errors),
+            border_style="red"
+        ))
+    
+    return all_passed, all_errors, zip_name 

adam_community-0.2/adam_community/cli/cli.py

@@ -0,0 +1,44 @@
+import click
+import json
+from pathlib import Path
+from .parser import parse_directory
+from .build import build_package
+
+@click.group()
+def cli():
+    """Adam Community CLI 工具"""
+    pass
+
+@cli.command()
+@click.argument('directory', type=click.Path(exists=True, file_okay=False, dir_okay=True), default='.')
+def parse(directory):
+    """解析指定目录下的所有 Python 文件并生成 functions.json"""
+    directory_path = Path(directory)
+    all_functions = parse_directory(directory_path)
+    
+    # 将结果写入 functions.json
+    output_file = directory_path / 'functions.json'
+    with open(output_file, 'w', encoding='utf-8') as f:
+        json.dump(all_functions, f, indent=2, ensure_ascii=False)
+    
+    click.echo(f"已成功解析 {len(all_functions)} 个类，结果保存在 {output_file}")
+
+@cli.command()
+@click.argument('directory', type=click.Path(exists=True, file_okay=False, dir_okay=True), default='.')
+def build(directory):
+    """构建项目包"""
+    directory_path = Path(directory)
+    
+    # 执行构建
+    success, errors, zip_name = build_package(directory_path)
+    
+    if success:
+        click.echo(f"包创建成功: {zip_name}")
+    else:
+        click.echo("检查未通过，发现以下问题：")
+        for error in errors:
+            click.echo(f"- {error}")
+        raise click.Abort()
+
+if __name__ == '__main__':
+    cli()

adam_community-0.2/adam_community/cli/parser.py

@@ -0,0 +1,121 @@
+import ast
+from pathlib import Path
+from typing import List, Dict, Any
+from docstring_parser import parse as dsp
+
+def parse_python_file(file_path: Path) -> List[Dict[str, Any]]:
+    """解析单个 Python 文件，提取类信息
+    
+    Args:
+        file_path: Python 文件路径
+        
+    Returns:
+        List[Dict[str, Any]]: 类信息列表
+    """
+    try:
+        with open(file_path, 'r', encoding='utf-8') as f:
+            content = f.read()
+        
+        tree = ast.parse(content)
+        classes = []
+        
+        for node in ast.walk(tree):
+            if isinstance(node, ast.ClassDef):
+                # 获取类的文档字符串
+                docstring = ast.get_docstring(node) or ""
+                
+                # 获取类的静态变量
+                sif_var = None
+                network_var = None
+                gpu = 0
+                cpu = 1
+                mem_per_cpu = 4000
+                partition = "gpu"
+                conda_env = "base"
+                
+                for item in node.body:
+                    if isinstance(item, ast.Assign):
+                        for target in item.targets:
+                            if isinstance(target, ast.Name):
+                                if target.id == 'SIF':
+                                    if isinstance(item.value, ast.Constant):
+                                        sif_var = item.value.value
+                                elif target.id == 'NETWORK':
+                                    if isinstance(item.value, ast.Constant):
+                                        network_var = item.value.value
+                                elif target.id == 'GPU':
+                                    if isinstance(item.value, ast.Constant):
+                                        gpu = item.value.value
+                                elif target.id == 'CPU':
+                                    if isinstance(item.value, ast.Constant):
+                                        cpu = item.value.value
+                                elif target.id == 'MEM_PER_CPU':
+                                    if isinstance(item.value, ast.Constant):
+                                        mem_per_cpu = item.value.value
+                                elif target.id == 'PARTITION':
+                                    if isinstance(item.value, ast.Constant):
+                                        partition = item.value.value
+                                elif target.id == 'CONDA_ENV':
+                                    if isinstance(item.value, ast.Constant):
+                                        conda_env = item.value.value
+                                elif target.id == 'DISPLAY_NAME':
+                                    if isinstance(item.value, ast.Constant):    
+                                        display_name = item.value.value
+                
+                # 获取类的参数信息
+                parameters = {
+                    "type": "object",
+                    "properties": {},
+                    "required": []
+                }
+                
+                # 使用 docstring_parser 解析类的文档字符串
+                docs = dsp(docstring)
+                if docs:
+                    for p in docs.params:
+                        parameters["properties"][p.arg_name] = {
+                            "description": p.description or "",
+                            "type": p.type_name or "string"
+                        }
+                        if not p.is_optional:
+                            parameters["required"].append(p.arg_name)
+                
+                class_info = {
+                    "function": {
+                        "name": f"{file_path.stem}.{node.name}",
+                        "description": docs.short_description if docs else "",
+                        "parameters": parameters,
+                        "file": str(file_path),
+                        "sif": sif_var,
+                        "network": network_var,
+                        "gpu": gpu,
+                        "cpu": cpu,
+                        "mem_per_cpu": mem_per_cpu,
+                        "partition": partition,
+                        "conda_env": conda_env,
+                        "display_name": display_name
+                    }
+                }
+                classes.append(class_info)
+        
+        return classes
+    except Exception as e:
+        print(f"解析文件 {file_path} 时出错: {str(e)}")
+        return []
+
+def parse_directory(directory: Path) -> List[Dict[str, Any]]:
+    """解析目录下的所有 Python 文件
+    
+    Args:
+        directory: 目录路径
+        
+    Returns:
+        List[Dict[str, Any]]: 所有类信息列表
+    """
+    all_classes = []
+    # 排除 config 目录
+    for py_file in directory.rglob('*.py'):
+        if not py_file.name.startswith('_') and 'config' not in py_file.parts:
+            classes = parse_python_file(py_file)
+            all_classes.extend(classes)
+    return all_classes 

adam_community-0.2/adam_community/tool.py

@@ -0,0 +1,143 @@
+import logging
+import os
+from .util import markdown_color, markdown_terminal
+
+class Tool:
+    logger = logging.getLogger("ADAM-TOOL")
+
+    def __init_subclass__(cls, **kwargs):
+        super().__init_subclass__()
+
+        for key, value in kwargs.items():
+            setattr(cls, key, value)
+        if not hasattr(cls, "GPU"):
+            cls.GPU = 0
+        if not hasattr(cls, "CPU"):
+            cls.CPU = 1
+        if not hasattr(cls, "MEM_PER_CPU"):
+            cls.MEM_PER_CPU = 4000
+        if not hasattr(cls, "PARTITION"):
+            cls.PARTITION = "gpu_3090"
+        if not hasattr(cls, "CONDA_ENV"):
+            cls.CONDA_ENV = "base"
+        if not hasattr(cls, "calltype"):
+            cls.calltype = "bash"
+
+
+    def inputShow(self, **kwargs):
+        """
+            AI决定使用该工具时调用，用于打印信息告知用户目前调用的工具
+            此处的kwargs更改对后续过程无效
+
+            :param dict args: 字典形式的AI产生的输入
+            :param list[str] files: 此次用户上传的文件
+            :param str message: 此次用户询问的消息
+            :param str user: 用户昵称
+            :param str task_id: 任务编号
+        """
+        if self.calltype == "bash":
+            os.environ["ADAM_OUTPUT_RAW"] = "true"
+            scripts = self.call(self, kwargs)
+            os.environ["ADAM_OUTPUT_RAW"] = "false"
+
+            scripts = '\n'.join(['bash -s << EOF', scripts, 'EOF'])
+        else:
+            scripts = f"""python {self.__name__}.py"""
+        return Tool.markdown_terminal(scripts, workdir=kwargs["task_id"],
+                user=kwargs["user"], conda_env=self.CONDA_ENV)
+
+    def resAlloc(self, kwargs):
+        """
+            提交工具任务时调用，用于获取分配的资源量
+            此处的kwargs更改只有tool_data和tip对后续过程有效
+
+            kwarg在inputShow的基础之上新增：
+            :param any tool_data: 可序列化的任意数据
+            :param str tip: 用来给用户显示的提示
+            :returns: 一个字典，包括使用的GPU、CPU和MEM_PER_CPU（以MB单位的整数）
+        """
+        return {"CPU": self.CPU, "MEM_PER_CPU": self.MEM_PER_CPU,
+                "GPU": self.GPU, "PARTITION": self.PARTITION}
+
+    def call(self, kwargs):
+        """
+            实际执行脚本
+            此处的kwargs更改只有tool_data，tip和token_usage对后续过程有效
+
+            kwarg同resAlloc
+            :returns: calltype=bash时，返回实际运行的bash脚本；
+                calltype=python时，return调用值无效
+        """
+        raise NotImplementedError
+
+
+    def monitor(self, kwargs):
+        """
+            任务运行时的监控命令，用于告知用户目前的进度
+            只有在return为True时，此处的kwargs更改tool_data、tip和progress对后续过程有效
+
+            kwargs在call的基础之上新增：
+            :param int run_time: 以秒为单位的运行时间
+            :param float progress: 任务进度，1为任务完成，0.5为50%，以此类推
+        """
+        pass
+
+    def outputShow(self, kwargs):
+        """
+            任务结束时调用，用于打印信息告知用户工具结果
+
+            kwargs在monitor的基础上新增：
+            :param str stdout: stdout流的结果
+            :param str stderr: stderr流的结果
+            :param int exit_code: 退出码
+            :returns: 一个给用户的文本, 一个包含显示文件的列表
+        """
+        stdout = kwargs["stdout"]
+        if len(stdout) > 10000:
+            stdout = stdout[:5000] + "\n...输出太长已省略...\n" + stdout[-5000:]
+        
+        stderr = kwargs["stderr"]
+        if len(stderr) > 10000:
+            stderr = stderr[:5000] + "\n...输出太长已省略...\n" + stderr[-5000:]
+        return f'''- exit code: {kwargs['exit_code']}
+- stdout:
+```
+{stdout}
+```
+- stderr:
+```
+{stderr}
+```
+''', []
+
+    def summary(self, kwargs):
+        """
+            任务结束时调用，用于打印信息告知AI结果
+
+            kwargs同outputShow
+            :returns: 一个给AI的文本
+        """
+        stdout = kwargs["stdout"]
+        if len(stdout) > 10000:
+            stdout = stdout[:5000] + "\n...输出太长已省略...\n" + stdout[-5000:]
+        stderr = kwargs["stderr"]
+        if len(stderr) > 10000:
+            stderr = stderr[:5000] + "\n...输出太长已省略...\n" + stderr[-5000:]
+        return f'''- exit code: {kwargs['exit_code']}
+- stdout:
+```
+{stdout}
+```
+- stderr:
+```
+{stderr}
+```
+'''
+
+    @staticmethod
+    def markdown_color(content, color):
+        return markdown_color(content, color)
+
+    @staticmethod
+    def markdown_terminal(content, conda_env="base", user="Adam", workdir=""):
+        return markdown_terminal(content, conda_env, user, workdir)

adam_community-0.2/adam_community/util.py

@@ -0,0 +1,345 @@
+import time
+import urllib.request
+import urllib.error
+import json
+import subprocess
+import sys
+import os
+import select
+import logging
+import ssl
+from functools import wraps
+from subprocess import run, CalledProcessError
+
+logger = logging.getLogger(__name__)
+
+ADAM_API_HOST = os.getenv('ADAM_API_HOST', 'https://sidereus-ai.com')
+ADAM_API_TOKEN = os.getenv('ADAM_API_TOKEN')
+ADAM_TASK_ID = os.getenv('ADAM_TASK_ID')
+ADAM_USER_ID = os.getenv('ADAM_USER_ID')
+CONDA_ENV = os.getenv('CONDA_ENV')
+
+# 定义可用的知识库集合
+collections = ["DSDP","MPNN","PySCF","RFdiffusion","gaussian","protenix","GPU4PySCF","MolecularDynamics","RDkit","OpenBabel", "SPONGE", "Xponge", "MDAnalysis", "ABACUS"]
+
+class RAG:
+    """
+    搜寻RAG知识
+
+    :param str query: 需要运行的命令
+    :param str collection: 搜寻的知识库名称。必须是下面之一："DSDP","MPNN","PySCF","RFdiffusion","gaussian","protenix","GPU4PySCF","MolecularDynamics","RDkit","OpenBabel"
+    """
+
+    def call(self, query: str, collection: str):
+
+        if collection not in collections:
+            raise ValueError(f"知识库名称必须是下面之一：{collections}")
+
+        cmd = f"""akb simple-query \
+    -i /share/programs/akb/database/{collection}/{collection}.index \
+    -m /share/programs/BAAI/bge-m3 \
+    -p /share/programs/akb/database/{collection}/{collection}.parquet \
+    -l 5 \
+    -f json -q \"{query}\""""
+        logger.info(f"搜索知识库 {collection}: {query}")
+        try:
+            result = run(cmd, shell='/bin/bash', check=True, text=True, capture_output=True)
+        except CalledProcessError as e:
+            logger.error(e.stderr.strip())
+            return e.stderr.strip()
+
+        try:
+            return "\n".join(json.loads(result.stdout))
+        except Exception as e:
+            logger.error(e)
+            return result.stdout
+
+
+def retry_on_exception(max_retries=3, delay=5):
+    """
+    重试装饰器，在发生异常时最多重试指定次数
+    
+    Args:
+        max_retries: 最大重试次数
+        delay: 重试间隔时间（秒）
+    """
+    def decorator(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            last_exception = None
+            for attempt in range(max_retries):
+                try:
+                    return func(*args, **kwargs)
+                except Exception as e:
+                    last_exception = e
+                    if attempt < max_retries - 1:
+                        time.sleep(delay)
+                        continue
+                    raise last_exception
+            return None
+        return wrapper
+    return decorator
+
+
+def _make_http_request(url, data, return_json=True):
+    """
+    通用的 HTTP POST 请求函数
+    
+    Args:
+        url: 请求的 URL
+        data: 请求数据（字典格式）
+        return_json: 是否将响应解析为 JSON，False 则返回文本
+    
+    Returns:
+        响应数据（JSON 或文本）
+    """
+    if not ADAM_API_TOKEN:
+        raise ValueError("ADAM_API_TOKEN environment variable is not set")
+    
+    headers = {
+        "Authorization": f"Bearer {ADAM_API_TOKEN}",
+        "Content-Type": "application/json"
+    }
+
+    try:
+        # 将请求数据转换为JSON字符串并编码
+        json_data = json.dumps(data).encode('utf-8')
+        
+        # 创建请求对象
+        req = urllib.request.Request(url, data=json_data, headers=headers, method='POST')
+        
+        context = ssl._create_unverified_context()
+
+        # 发送请求
+        with urllib.request.urlopen(req, context=context) as response:
+            # 检查响应状态码
+            if response.status >= 400:
+                raise Exception(f"HTTP错误: {response.status}")
+            
+            # 读取响应
+            response_data = response.read().decode('utf-8')
+            
+            # 根据需要返回 JSON 或文本
+            if return_json:
+                return json.loads(response_data)
+            else:
+                return response_data
+                
+    except urllib.error.HTTPError as e:
+        raise Exception(f"HTTP请求失败 - HTTP错误 {e.code}: {e.reason}")
+    except urllib.error.URLError as e:
+        raise Exception(f"HTTP请求失败 - 网络错误: {str(e)}")
+    except json.JSONDecodeError as e:
+        if return_json:
+            raise Exception(f"HTTP请求失败 - JSON解析错误: {str(e)}")
+        else:
+            raise Exception(f"HTTP请求失败 - 响应解码错误: {str(e)}")
+    except Exception as e:
+        raise Exception(f"HTTP请求失败: {str(e)}")
+
+
+def messageSend(message):
+    """
+    发送消息给用户
+    """
+    if not ADAM_API_HOST:
+        raise ValueError("ADAM_API_HOST environment variable is not set")
+    if not ADAM_TASK_ID:
+        raise ValueError("ADAM_TASK_ID environment variable is not set")
+
+    url = f"{ADAM_API_HOST}/api/task/create_message"
+    
+    request_data = {
+        "task_id": ADAM_TASK_ID,
+        "message": message,
+        "role": "tool"
+    }
+
+    try:
+        return _make_http_request(url, request_data, return_json=True)
+    except Exception as e:
+        raise Exception(f"发送消息失败: {str(e)}")
+
+
+@retry_on_exception(max_retries=3)
+def knowledgeSearch(query_info, messages_prev, project_name, collection_name, max_messages=4):
+    """
+    知识库检索函数
+    """
+    if not collection_name:
+        raise ValueError("collection_name 参数是必需的")
+
+    if collection_name not in collections:
+        raise ValueError(f"知识库名称必须是下面之一：{collections}")
+
+    try:
+        # 使用本地RAG实现
+        rag = RAG()
+        result = rag.call(query_info, collection_name)
+
+        # 构造返回格式，保持与原有API格式一致
+        response_data = {
+            "code": 0,
+            "data": {
+                "collection_name": collection_name,
+                "count": 1,
+                "result_list": [{
+                    "chunk_id": 0,
+                    "chunk_source": "document",
+                    "chunk_title": result.split("\n")[0] if result else "",
+                    "chunk_type": "text",
+                    "content": result,
+                    "doc_info": {
+                        "create_time": 0,
+                        "doc_id": "local_doc",
+                        "doc_name": f"{collection_name}_knowledge",
+                        "doc_type": "text",
+                        "source": "local"
+                    },
+                    "score": 1.0
+                }],
+                "token_usage": {
+                    "embedding_token_usage": {
+                        "completion_tokens": 0,
+                        "prompt_tokens": 0,
+                        "total_tokens": 0
+                    },
+                    "rerank_token_usage": 0
+                }
+            },
+            "message": "success",
+            "request_id": "local_request"
+        }
+
+        return json.dumps(response_data, ensure_ascii=False)
+    except Exception as e:
+        error_response = {
+            "code": 1,
+            "message": f"知识库搜索失败: {str(e)}"
+        }
+        return json.dumps(error_response, ensure_ascii=False)
+
+
+class DynamicObject:
+    """
+    动态对象类，用于处理 JSON 响应
+    
+    这个类可以动态地将字典转换为对象属性，支持嵌套的字典结构
+    同时保持原始数据的访问能力
+    """
+    def __init__(self, data):
+        self._raw_data = data
+        if isinstance(data, dict):
+            for key, value in data.items():
+                if isinstance(value, (dict, list)):
+                    setattr(self, key, self._convert_value(value))
+                else:
+                    setattr(self, key, value)
+    
+    def _convert_value(self, value):
+        """递归转换嵌套的数据结构"""
+        if isinstance(value, dict):
+            return DynamicObject(value)
+        elif isinstance(value, list):
+            return [self._convert_value(item) for item in value]
+        return value
+    
+    def __getattr__(self, name):
+        """处理未定义的属性访问"""
+        return self._raw_data.get(name)
+    
+    def __getitem__(self, key):
+        """支持字典式访问"""
+        return self._raw_data.get(key)
+    
+    def __str__(self):
+        """返回可读的字符串表示"""
+        return f"DynamicObject({self._raw_data})"
+    
+    def __repr__(self):
+        return self.__str__()
+    
+    def to_dict(self):
+        """将对象转换回字典"""
+        return self._raw_data
+
+
+@retry_on_exception(max_retries=3)
+def completionCreate(request_params):
+    """
+    创建 openai 的代理函数
+    
+    Returns:
+        DynamicObject: 一个动态对象，可以像访问属性一样访问 API 响应的所有字段
+    """
+    if not ADAM_API_HOST:
+        raise ValueError("ADAM_API_HOST environment variable is not set")
+
+    url = f"{ADAM_API_HOST}/api/chat/completions"
+    
+    try:
+        response = _make_http_request(url, request_params, return_json=True)
+        return DynamicObject(response)
+    except Exception as e:
+        raise Exception(f"调用聊天补全接口失败: {str(e)}")
+
+def runCmd(cmd):
+    """
+    执行命令，实时输出执行结果
+
+    修复了原实现中可能存在的阻塞和内容丢失问题
+    """
+    if os.getenv("ADAM_OUTPUT_RAW"):
+        return cmd
+
+    process = subprocess.Popen(
+        cmd,
+        shell=True,
+	executable='/bin/bash',
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        universal_newlines=True,
+        bufsize=1
+    )
+
+    try:
+        # 使用 select 来同时监控 stdout 和 stderr，避免阻塞
+        while True:
+            # 检查进程是否已结束
+            if process.poll() is not None:
+                break
+
+            # 使用 select 来检查是否有可读的数据
+            rlist, _, _ = select.select([process.stdout, process.stderr], [], [], 0.1)
+
+            for stream in rlist:
+                line = stream.readline()
+                if line:
+                    if stream == process.stdout:
+                        print(line.strip())
+                    else:
+                        print(line.strip(), file=sys.stderr)
+
+        # 读取剩余的输出（如果有）
+        for line in process.stdout:
+            print(line.strip())
+        for line in process.stderr:
+            print(line.strip(), file=sys.stderr)
+
+        # 检查返回码
+        if process.returncode != 0:
+            sys.exit(process.returncode)
+
+        return process
+    finally:
+        # 确保所有文件描述符都被关闭
+        process.stdout.close()
+        process.stderr.close()
+
+def markdown_color(content, color):
+    return f'<span style="color: {color}">{content}</span>'
+
+def markdown_terminal(content, conda_env="base", user="Adam", workdir=""):
+    user = markdown_color(f"{user}@Adam", "green")
+    workdir = markdown_color(f":~/{workdir}", "blue")
+    return f'({conda_env}) {user}{workdir}$ {content}'

adam_community-0.2/adam_community.egg-info/PKG-INFO

@@ -0,0 +1,53 @@
+Metadata-Version: 2.4
+Name: adam_community
+Version: 0.2
+Summary: Adam Community Tools and Utilities
+Home-page: https://github.com/yourusername/adam-community
+Author: Adam Community
+Author-email: admin@sidereus-ai.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.31.0
+Requires-Dist: click>=8.0.0
+Requires-Dist: docstring-parser>=0.15
+Requires-Dist: rich>=13.0.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Adam Community
+
+Adam Community 是一个 Python 工具包，提供了一系列实用工具和功能，用于与 Adam 社区相关的开发工作。
+
+安装依赖：
+```bash
+make install
+```
+
+
+## 使用方法
+
+安装完成后，您可以在 Python 代码中导入并使用该包：
+
+```python
+from adam_community import tool
+from adam_community import util
+
+# 使用相关功能
+```
+
+## 开发
+
+运行测试：
+```bash
+make test
+```

adam_community-0.2/adam_community.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+README.md
+setup.py
+adam_community/__init__.py
+adam_community/tool.py
+adam_community/util.py
+adam_community.egg-info/PKG-INFO
+adam_community.egg-info/SOURCES.txt
+adam_community.egg-info/dependency_links.txt
+adam_community.egg-info/entry_points.txt
+adam_community.egg-info/requires.txt
+adam_community.egg-info/top_level.txt
+adam_community/cli/__init__.py
+adam_community/cli/build.py
+adam_community/cli/cli.py
+adam_community/cli/parser.py
+test/test_util_tool.py

adam_community-0.2/adam_community.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

adam_community-0.2/adam_community.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+adam-cli = adam_community.cli.cli:cli

adam_community-0.2/adam_community.egg-info/requires.txt

@@ -0,0 +1,4 @@
+requests>=2.31.0
+click>=8.0.0
+docstring-parser>=0.15
+rich>=13.0.0

adam_community-0.2/adam_community.egg-info/top_level.txt

@@ -0,0 +1 @@
+adam_community

adam_community-0.2/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

adam_community-0.2/setup.py

@@ -0,0 +1,31 @@
+from setuptools import setup, find_packages
+import os
+
+setup(
+    name="adam_community",
+    version="0.2",
+    packages=find_packages(),
+    install_requires=[
+        "requests>=2.31.0",
+        "click>=8.0.0",
+        "docstring-parser>=0.15",
+        "rich>=13.0.0",
+    ],
+    entry_points={
+        'console_scripts': [
+            'adam-cli=adam_community.cli.cli:cli',
+        ],
+    },
+    author="Adam Community",
+    author_email="admin@sidereus-ai.com",
+    description="Adam Community Tools and Utilities",
+    long_description=open("README.md").read() if os.path.exists("README.md") else "",
+    long_description_content_type="text/markdown",
+    url="https://github.com/yourusername/adam-community",
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+    ],
+    python_requires=">=3.8",
+) 

adam_community-0.2/test/test_util_tool.py

@@ -0,0 +1,143 @@
+import unittest
+from unittest.mock import patch, MagicMock, PropertyMock
+import sys
+import os
+
+# 设置环境变量
+os.environ['ADAM_API_TOKEN'] = 'test_token'
+os.environ['ADAM_API_HOST'] = 'https://test.com'
+
+# 添加项目根目录到 Python 路径
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+# Mock OpenAI client before importing util
+with patch('openai.OpenAI'):
+    from adam_community.util import knowledgeSearch, completionCreate, runCmd
+    from adam_community.tool import Tool
+
+class TestUtil(unittest.TestCase):
+    def setUp(self):
+        self.test_params = {
+            "project": "test_project",
+            "name": "test_collection",
+            "query": "test query",
+            "limit": 10
+        }
+        
+    @patch('urllib.request.urlopen')
+    def test_knowledgeSearch(self, mock_urlopen):
+        """测试knowledgeSearch函数"""
+        mock_response = MagicMock()
+        # 设置status属性为整数
+        type(mock_response).status = PropertyMock(return_value=200)
+        mock_response.read.return_value = b'{"result": "success"}'
+        mock_urlopen.return_value.__enter__.return_value = mock_response
+        
+        result = knowledgeSearch(
+            query_info="test query",
+            messages_prev=[{"role": "user", "content": "test"}],
+            project_name="test_project",
+            collection_name="test_collection"
+        )
+        
+        self.assertEqual(result, '{"result": "success"}')
+        mock_urlopen.assert_called_once()
+
+    @patch('subprocess.Popen')
+    @patch.dict(os.environ, {'ADAM_OUTPUT_RAW': ''}, clear=True)
+    def test_runCmd_success(self, mock_popen):
+        """测试runCmd函数成功执行命令的情况"""
+        mock_process = MagicMock()
+        mock_process.poll.return_value = 0
+        mock_process.returncode = 0
+        mock_process.stdout.readline.return_value = "test output"
+        mock_process.stderr.readline.return_value = ""
+        mock_popen.return_value = mock_process
+        
+        process = runCmd('echo "test output"')
+        self.assertEqual(process.returncode, 0)
+        mock_popen.assert_called_once()
+
+    @patch('subprocess.Popen')
+    @patch.dict(os.environ, {'ADAM_OUTPUT_RAW': ''}, clear=True)
+    def test_runCmd_failure(self, mock_popen):
+        """测试runCmd函数执行失败的情况"""
+        mock_process = MagicMock()
+        mock_process.poll.return_value = 1
+        mock_process.returncode = 1
+        mock_process.stdout.readline.return_value = ""
+        mock_process.stderr.readline.return_value = "command not found"
+        mock_popen.return_value = mock_process
+        
+        with self.assertRaises(SystemExit) as cm:
+            runCmd('nonexistent_command_123456')
+        self.assertEqual(cm.exception.code, 1)
+
+    @patch.dict(os.environ, {'ADAM_OUTPUT_RAW': 'true'}, clear=True)
+    def test_runCmd_with_raw_output(self):
+        """测试runCmd函数在ADAM_OUTPUT_RAW环境变量设置时的情况"""
+        cmd = 'echo "test output"'
+        result = runCmd(cmd)
+        self.assertEqual(result, cmd)
+
+class TestTool(unittest.TestCase):
+    def setUp(self):
+        class TestToolImpl(Tool):
+            def call(self, kwargs):
+                return "test command"
+        
+        self.tool = TestToolImpl()
+        
+    def test_inputShow(self):
+        """测试inputShow方法"""
+        kwargs = {
+            "task_id": "test_task",
+            "user": "test_user",
+            "message": "test message"
+        }
+        
+        with patch.object(self.tool, 'call', return_value="test command"):
+            result = self.tool.inputShow(**kwargs)
+            self.assertIn("test_user@Adam", result)
+            self.assertIn("test_task", result)
+        
+    def test_resAlloc(self):
+        """测试resAlloc方法"""
+        kwargs = {
+            "tool_data": "test_data",
+            "tip": "test tip"
+        }
+        
+        result = self.tool.resAlloc(kwargs)
+        self.assertIn("CPU", result)
+        self.assertIn("MEM_PER_CPU", result)
+        self.assertIn("GPU", result)
+        self.assertIn("PARTITION", result)
+        
+    def test_outputShow(self):
+        """测试outputShow方法"""
+        kwargs = {
+            "stdout": "test stdout",
+            "stderr": "test stderr",
+            "exit_code": 0
+        }
+        
+        result, files = self.tool.outputShow(kwargs)
+        self.assertIn("test stdout", result)
+        self.assertIn("test stderr", result)
+        self.assertEqual(files, [])
+        
+    def test_markdown_color(self):
+        """测试markdown_color静态方法"""
+        result = Tool.markdown_color("test", "red")
+        self.assertEqual(result, '<span style="color: red">test</span>')
+        
+    def test_markdown_terminal(self):
+        """测试markdown_terminal静态方法"""
+        result = Tool.markdown_terminal("test command", "test_env", "test_user", "test_dir")
+        self.assertIn("test_user@Adam", result)
+        self.assertIn("test_dir", result)
+        self.assertIn("test command", result)
+
+if __name__ == '__main__':
+    unittest.main()