alayaflow 0.1.0__py3-none-any.whl

alayaflow/component/retrieve_node.py

@@ -0,0 +1,17 @@
+from urllib import request
+from alayaflow.clients.alayamem.http_client import HttpAlayaMemClient
+
+
+class RetrieveComponent:
+    def __init__(self, client: HttpAlayaMemClient):
+        self.client = client
+    
+    def __call__(self, query: str, collection_name: str, limit: int = 3) -> list[str]:
+        result = self.client.vdb_query([query], limit, collection_name)
+        return result.get('documents', [[]])[0] if result.get('documents') else []
+
+if __name__ == "__main__":
+    client = HttpAlayaMemClient("http://10.16.70.46:5555")
+    res = client.vdb_query(messages="姓名", limit=5, collection_name="file_watcher_collection")
+
+    print(res)

alayaflow/component/web_search.py

@@ -0,0 +1,126 @@
+from platform import java_ver
+from langgraph.graph import StateGraph
+from langgraph.graph.state import RunnableConfig
+from pydantic import BaseModel
+import requests
+from typing import Annotated, Type, TypedDict, Optional
+# from langchain_core.annotations import InjectedToolArg
+
+from langchain_openai import ChatOpenAI
+
+from alayaflow.common.config import settings
+
+from langgraph.graph import START, END
+from langchain.tools import tool
+
+"""
+结点参数
+- 每个结点使用的时候有固定的参数
+    - 1. 工作流定义中传入
+- 包含结点的工作流创建的时候有全局变量，来配置工作流
+    - 2. 工作流创建时输入的全局变量
+- 结点运行时有输入参数
+    - 3. 工作流运行时输入 （来自用户）
+    - 4. 运行时上游结点的输出
+
+调用方式
+- 放入langgraph中作单独结点
+- 放入langflow component实现中
+- ~放入LLM结点作tools~
+"""
+
+# Core
+
+def search(query, url, item_cnt, api_key):
+    # return requests.get(
+    #     f"{url}/search",
+    #     headers={"Authorization": f"Bearer {search_api_key}"},
+    #     params={"query": query, "item": return_item_cnt}
+    # ).json()
+    
+    # Fake run
+    return f"Get request from {url} with headers={{'Authorization': 'Bearer {api_key}'}} and params={{'query': {query}, 'item': {item_cnt}}}"
+
+# @tool
+# def search_as_tool(
+#     query: str, 
+#     # 告诉 LangChain：这些参数不要给 LLM 看，由代码注入
+#     config: Annotated[dict, InjectedToolArg] 
+# ):
+#     """搜索工具，用于获取特定信息。"""
+#     # 从注入的 config 中提取配置
+#     return search(
+#         query=query,
+#         url=config["url"],
+#         api_key=config["api_key"],
+#         item_cnt=config.get("item_cnt", 3)
+#     )
+
+
+# Workflow developer layer
+
+class MyState(BaseModel):
+    query: str
+    search_result: Optional[str] = None
+
+# class SearchNode:
+#     def __init__(self, key: str):
+#         self.key = key
+    
+#     def __call__(self, state: MyState):
+#         new_state = state.model_copy()
+#         new_state.search_result = search(
+#             state.query,
+#             "https://xxx",    # 1
+#             3,       # 1
+#             self.key,  # 2
+#         )
+#         return new_state
+
+
+def create_search_node(api_key: str):
+    
+    def search_node(state: MyState, config: RunnableConfig):
+        result = search(
+            query=state.query, 
+            url=config["configurable"]["search_url"],
+            api_key=config["configurable"]["search_api_key"],
+            item_cnt=3,
+        )
+        return {"search_result": result}
+    return search_node
+
+
+def create_graph(search_api_key):
+    builder = StateGraph(MyState)
+
+    # 添加节点
+    builder.add_node("search", create_search_node(search_api_key))
+
+    # 定义边
+    builder.add_edge(START, "search")
+    builder.add_edge("search", END)
+
+    return builder.compile()
+
+class WFConfig(TypedDict):
+    search_api_key: str
+    search_url: str
+
+def get_config_schema() -> Type[TypedDict]:
+    return WFConfig
+
+
+graph = create_graph(search_api_key="xxx")  # 2
+result = graph.invoke({
+    "query": "唐博",     # 3
+}, config={
+    "configurable": WFConfig(
+        search_api_key="abc",
+        search_url="https://xxxx",
+    )
+})
+
+
+print(f"result: {result}")
+

alayaflow/execution/__init__.py

@@ -0,0 +1,6 @@
+from .executor_manager import ExecutorManager, ExecutorType
+
+__all__ = [
+    "ExecutorManager",
+    "ExecutorType"
+]

alayaflow/execution/env_manager.py

@@ -0,0 +1,424 @@
+import os
+import sys
+import json
+import shutil
+import subprocess
+import hashlib
+from pathlib import Path
+from typing import List, Dict, Optional, Set, Tuple
+
+from alayaflow.common.config import settings
+
+
+class EnvManager:
+    """
+    使用 uv (Rust-based tool) 替代 venv + pip。
+    提供极速的环境创建和 Python 版本管理。
+    增强功能：根据requirements自动匹配现有环境
+    """
+
+    def __init__(self):
+        self.base_dir = settings.envs_dir
+        if not os.path.exists(self.base_dir):
+            os.makedirs(self.base_dir)
+
+        # 检查 uv 是否存在
+        if shutil.which("uv") is None:
+            print("[Warning] 'uv' command not found! Please install uv first.")
+            # 在实际桌面应用中，你应该将 uv 的二进制文件打包在你的应用里，
+            # 并在这里指定绝对路径，例如: self.uv_bin = "./bin/uv.exe"
+            self.uv_bin = "uv"
+        else:
+            self.uv_bin = "uv"
+
+        # 元数据存储
+        self.metadata_file = os.path.join(self.base_dir, "envs_metadata.json")
+        self.env_metadata = self._load_metadata()
+
+        # 初始化时扫描所有现有环境并更新包信息
+        self._scan_existing_envs()
+
+    def _load_metadata(self) -> Dict:
+        """加载环境元数据"""
+        if os.path.exists(self.metadata_file):
+            try:
+                with open(self.metadata_file, 'r') as f:
+                    return json.load(f)
+            except json.JSONDecodeError:
+                return {}
+        return {}
+
+    def _save_metadata(self):
+        """保存环境元数据"""
+        with open(self.metadata_file, 'w') as f:
+            json.dump(self.env_metadata, f, indent=2)
+
+    # def get_venv_path(self, workflow_id: str, version: str) -> str:
+    #     return os.path.join(self.base_dir, f"{workflow_id}_{version}")
+
+    def get_venv_path_by_name(self, env_name: str) -> str:
+        return os.path.join(self.base_dir, env_name)
+
+    def get_python_executable(self, env_path: str) -> str:
+        # uv 创建的 venv 结构和标准 venv 一样
+        if sys.platform == "win32":
+            return os.path.join(env_path, "Scripts", "python.exe")
+        return os.path.join(env_path, "bin", "python")
+
+    def _get_python_version(self, env_path: str) -> str:
+        """使用subprocess调用python print获取环境的Python版本"""
+        python_exe = self.get_python_executable(env_path)
+        try:
+            cmd = [python_exe, "-c", "import sys; print(f'{sys.version_info.major}.{sys.version_info.minor}')"]
+            result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+            return result.stdout.strip()
+        except:
+            return "unknown"
+
+    def _scan_existing_envs(self):
+        """扫描现有环境（子目录存在且有python_exe）并更新包信息"""
+        print("[UV] Scanning existing environments...")
+        for env_dir in os.listdir(self.base_dir):
+            # 跳过元数据文件
+            if env_dir == "envs_metadata.json":
+                continue
+            env_path = os.path.join(self.base_dir, env_dir)
+            # todo: consider if the following logic is clear. Seems not good
+            if os.path.isdir(env_path):
+                # 检查是否是有效的虚拟环境
+                python_exe = self.get_python_executable(env_path)
+                if os.path.exists(python_exe):
+                    if env_dir not in self.env_metadata:
+                        # 新发现的环境，生成包信息
+                        print(f"[UV] Found new environment: {env_dir}")
+                        self._update_env_packages(env_dir)
+        self._save_metadata()
+
+    def _update_env_packages(self, env_name: str):
+        """更新指定环境的包信息"""
+        env_path = self.get_venv_path_by_name(env_name)
+
+        try:
+            # 获取已安装的包列表
+            cmd = [self.uv_bin, "pip", "freeze", "-p", env_path]
+            result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+
+            packages = {}
+            for line in result.stdout.strip().split('\n'):
+                if line and '==' in line:
+                    name, version = line.split('==', 1)
+                    packages[name] = version
+
+            # 更新元数据
+            self.env_metadata[env_name] = {
+                "path": env_path,
+                "packages": packages,
+                "python_version": self._get_python_version(env_path),
+                # "requirements": []  # 初始安装的requirements（可选的）
+            }
+
+            print(f"[UV] Updated packages for {env_name}: {len(packages)} packages")
+
+        except subprocess.CalledProcessError as e:
+            print(f"[UV] Failed to scan packages for {env_name}: {e}")
+
+    def _parse_requirement(self, req_str: str) -> Tuple[str, str]:
+        """解析单个requirement字符串，返回包名和版本约束"""
+        # 移除注释和空格
+        req_str = req_str.split('#')[0].strip()
+        if not req_str:
+            return None, None
+
+        # 解析包名和版本
+        import re
+        # 匹配包名（允许字母、数字、点、下划线、连字符）
+        name_match = re.match(r'^([a-zA-Z0-9._-]+)', req_str)
+        if not name_match:
+            return None, None
+
+        name = name_match.group(1).lower()
+        version_spec = req_str[len(name):].strip()
+
+        # 标准化版本约束
+        if version_spec:
+            # 移除多余的空格
+            version_spec = version_spec.replace(' ', '')
+        else:
+            version_spec = "any"  # 未指定版本
+
+        return name, version_spec
+
+    def _check_package_compatibility(self, installed_ver: str, required_spec: str) -> bool:
+        """检查已安装版本是否满足要求"""
+        if required_spec == "any":
+            return True
+
+        from packaging.version import parse, Version
+        from packaging.specifiers import SpecifierSet
+
+        try:
+            # 解析已安装版本
+            installed = parse(installed_ver)
+            if not isinstance(installed, Version):
+                return False
+
+            # 解析版本要求
+            specifier = SpecifierSet(required_spec)
+            return installed in specifier
+
+        except Exception as e:
+            print(f"[EM] Version check error: {e}")
+            return False
+            # 如果解析失败，进行字符串比较作为后备
+        #     try:
+        #         # 简单的比较逻辑
+        #         if required_spec.startswith("=="):
+        #             return installed_ver == required_spec[2:]
+        #         elif required_spec.startswith(">="):
+        #             return installed_ver >= required_spec[2:]
+        #         elif required_spec.startswith("<="):
+        #             return installed_ver <= required_spec[2:]
+        #         elif required_spec.startswith(">"):
+        #             return installed_ver > required_spec[1:]
+        #         elif required_spec.startswith("<"):
+        #             return installed_ver < required_spec[1:]
+        #         elif required_spec.startswith("~="):
+        #             # 兼容版本：近似等于
+        #             base_version = parse(required_spec[2:])
+        #             installed_version = parse(installed_ver)
+        #             return (installed_version >= base_version and
+        #                     installed_version < base_version.next_minor())
+        #     except:
+        #         return False
+        #
+        # return True
+
+    def find_matching_env(self, requirements: List[str], python_version: str = None) -> Optional[str]:
+        """
+        查找满足requirements的现有环境
+
+        Args:
+            requirements: 包要求列表
+            python_version: 可选的Python版本要求
+
+        Returns:
+            匹配的环境名称，或None
+        """
+        if not requirements:
+            # 如果没有要求，返回第一个环境
+            return next(iter(self.env_metadata.keys()), None)
+
+        print(f"[EM] Looking for environment matching {len(requirements)} requirements...")
+
+        for env_name, metadata in self.env_metadata.items():
+            # 检查Python版本
+            if python_version and metadata.get("python_version") != python_version:
+                continue
+
+            env_packages = metadata.get("packages", {})
+            all_satisfied = True
+
+            for req in requirements:
+                if not req or req.startswith("#"):
+                    continue
+
+                pkg_name, version_spec = self._parse_requirement(req)
+                if not pkg_name:
+                    continue
+
+                # 检查包是否安装
+                if pkg_name not in env_packages:
+                    all_satisfied = False
+                    break
+
+                # 检查版本是否满足
+                installed_ver = env_packages[pkg_name]
+                if not self._check_package_compatibility(installed_ver, version_spec):
+                    all_satisfied = False
+                    break
+
+            if all_satisfied:
+                print(f"[EM] Found matching environment: {env_name}")
+                return env_name
+
+        print("[EM] No matching environment found")
+        return None
+
+    def create_new_env(self, env_name: str, python_version: str = "3.12") -> str:
+        """创建新的虚拟环境"""
+        env_path = self.get_venv_path_by_name(env_name)
+        python_exe = self.get_python_executable(env_path)
+
+        if not os.path.exists(python_exe):
+            print(f"[UV] Creating new VENV: {env_name}...")
+            try:
+                subprocess.check_call(
+                    [self.uv_bin, "venv", env_path, "--python", python_version],
+                    stdout=subprocess.DEVNULL
+                )
+                print(f"[UV] Venv created with Python {python_version}")
+            except subprocess.CalledProcessError as e:
+                print(f"[UV] Venv creation failed: {e}")
+                raise
+
+        return env_path
+
+    def ensure_env(self, workflow_id: str, version: str, requirements: List[str], use_venv: bool) -> str:
+        """
+        使用 uv 准备环境
+        先尝试匹配现有环境，如无匹配则创建新环境
+        """
+        if not use_venv:
+            return sys.executable
+
+        # 1. 首先尝试查找匹配的现有环境
+        env_name = self.find_matching_env(requirements)
+
+        if env_name:
+            # 使用现有环境
+            env_path = self.get_venv_path_by_name(env_name)
+            python_exe = self.get_python_executable(env_path)
+
+            print(f"[EM] Reusing existing environment: {env_name}")
+
+            # 检查是否安装了alayaflow
+            alayaflow_marker = os.path.join(env_path, "alayaflow_installed.marker")
+            if not os.path.exists(alayaflow_marker):
+                self._install_alayaflow(env_path)
+
+            return python_exe
+
+        # 2. 没有匹配的环境，创建新环境
+        import uuid
+        # todo: use function create_new_env instead?
+        # env_name = f"{workflow_id}_{version}"
+        # env_path = self.get_venv_path(workflow_id, version)
+        env_name=uuid.uuid4().hex
+        env_path = self.get_venv_path_by_name(env_name)
+        python_exe = self.get_python_executable(env_path)
+
+        # 1. 创建虚拟环境 (uv venv)
+        # 优势：如果指定了 python 版本，uv 会自动下载便携版，不需要系统预装
+        if not os.path.exists(python_exe):
+            print(f"[UV] Creating VENV for {workflow_id} v{version}...")
+            try:
+                # 假设我们想让这个环境使用 Python 3.12 (即使主程序是 3.9)
+                # 实际中你可以把 python_version 放在元数据里传进来
+                target_python = "3.12"
+
+                subprocess.check_call(
+                    [self.uv_bin, "venv", env_path, "--python", target_python],
+                    stdout=subprocess.DEVNULL
+                )
+                print(f"[UV] Venv created with Python {target_python}")
+            except subprocess.CalledProcessError as e:
+                print(f"[UV] Venv creation failed: {e}")
+                raise
+
+        # 2. 安装依赖 (uv pip install)
+        if requirements:
+            self._install_requirements(env_path, requirements)
+
+        # 安装 alayaflow
+        self._install_alayaflow(env_path)
+
+        # 更新环境元数据
+        self._update_env_packages(env_name)
+
+        return python_exe
+
+    def _install_requirements(self, env_path: str, requirements: List[str]):
+        """安装依赖"""
+        marker_file = os.path.join(env_path, "deps_installed.marker")
+        if not os.path.exists(marker_file):
+            print(f"[UV] Installing deps: {requirements}")
+            try:
+                cmd = [self.uv_bin, "pip", "install", "-p", env_path] + requirements
+
+                subprocess.check_call(
+                    cmd,
+                    stdout=subprocess.DEVNULL,
+                    stderr=subprocess.PIPE
+                )
+                with open(marker_file, "w") as f:
+                    f.write("ok")
+                print("[UV] Deps installed.")
+
+            except subprocess.CalledProcessError as e:
+                print(f"[UV] Install failed: {e}")
+                raise
+
+    def _install_alayaflow(self, env_path: str):
+        """安装alayaflow"""
+        # todo: Why this appear？
+        alayaflow_marker = os.path.join(env_path, "alayaflow_installed.marker")
+        if not os.path.exists(alayaflow_marker):
+            print("[UV] Installing alayaflow in worker env...")
+            try:
+                if settings.is_dev():
+                    # dev模式：可编辑安装
+                    subprocess.check_call(
+                        [self.uv_bin, "pip", "install", "-p", env_path, "-e", str(settings.alayaflow_root)]
+                    )
+                elif settings.is_uneditable_dev():
+                    # dev-uneditable：从项目根目录安装（非可编辑模式）
+                    print(f"[UV] Installing alayaflow from: {settings.alayaflow_root}")
+                    subprocess.check_call(
+                        [self.uv_bin, "pip", "install", "-p", env_path, str(settings.alayaflow_root)],
+                        stdout=subprocess.DEVNULL,
+                        stderr=subprocess.PIPE,
+                    )
+                elif settings.is_prod():
+                    # prod模式：从PyPI安装
+                    subprocess.check_call(
+                        [self.uv_bin, "pip", "install", "-p", env_path, "alayaflow"],
+                        stdout=subprocess.DEVNULL,
+                        stderr=subprocess.PIPE
+                    )
+                else:
+                    raise ValueError(f"Unknown dev_mode: {settings.dev_mode}")
+                with open(alayaflow_marker, "w") as f:
+                    f.write("ok")
+                print("[UV] Alayaflow installed.")
+            except subprocess.CalledProcessError as e:
+                print(f"[UV] Alayaflow installation failed: {e}")
+                raise
+
+    def list_environments(self) -> List[Dict]:
+        """列出所有环境及其信息"""
+        envs = []
+        for env_name, metadata in self.env_metadata.items():
+            env_info = {
+                "name": env_name,
+                "path": metadata.get("path", ""),
+                "python_version": metadata.get("python_version", "unknown"),
+                "package_count": len(metadata.get("packages", {})),
+            }
+            envs.append(env_info)
+        return envs
+
+    # def clean_orphaned_envs(self):
+    #     # 不想开放这个功能
+    #     """清理元数据中不存在的环境"""
+    #     env_dirs = os.listdir(self.base_dir)
+    #
+    #     # 找出元数据中有但实际不存在的环境
+    #     to_remove = []
+    #     for env_name in list(self.env_metadata.keys()):
+    #         env_path = self.get_venv_path_by_name(env_name)
+    #         if not os.path.exists(env_path):
+    #             to_remove.append(env_name)
+    #
+    #     # 清理元数据
+    #     for env_name in to_remove:
+    #         # del self.env_metadata[env_name]
+    #         print(f"[UV] Remove orphaned metadata for {env_name}")
+    #
+    #     if to_remove:
+    #         self._save_metadata()
+
+    def get_env_info(self, env_name: str) -> Optional[Dict]:
+        """获取环境的详细信息"""
+        if env_name in self.env_metadata:
+            return self.env_metadata[env_name]
+        return None

alayaflow/execution/executor_manager.py

@@ -0,0 +1,59 @@
+from typing import Generator, Dict, Optional
+from enum import Enum
+
+from alayaflow.execution.executors.base_executor import BaseExecutor
+from alayaflow.execution.executors.uv_executor import UvExecutor
+from alayaflow.execution.executors.naive_executor import NaiveExecutor
+from alayaflow.execution.executors.worker_executor import WorkerExecutor
+from alayaflow.workflow import WorkflowManager
+
+
+class ExecutorType(Enum):
+    UV = "uv"
+    NAIVE = "naive"
+    WORKER = "worker"
+
+
+class ExecutorManager:    
+    def __init__(
+        self,
+        workflow_manager: WorkflowManager
+    ):
+        self._workflow_manager = workflow_manager
+        self._executor_map: Dict[ExecutorType, BaseExecutor] = {}
+        self._initialize_executors()
+    
+    def _initialize_executors(self):
+        """Initialize all available executors."""
+        self._executor_map[ExecutorType.UV] = UvExecutor(
+            workflow_manager=self._workflow_manager
+        )
+        self._executor_map[ExecutorType.NAIVE] = NaiveExecutor(
+            workflow_manager=self._workflow_manager
+        )
+        self._executor_map[ExecutorType.WORKER] = WorkerExecutor(
+            workflow_manager=self._workflow_manager
+        )
+        
+    def init_workflow(self, workflow_id: str, version: str, init_args: dict):
+        for executor in self._executor_map.values():
+            executor.init_workflow(workflow_id, version, init_args)
+    
+    def exec_workflow(
+            self, 
+            workflow_id: str,
+            version: str, 
+            input_data: dict,
+            user_config: dict, 
+            executor_type: ExecutorType | str = ExecutorType.NAIVE
+    ) -> Generator[Dict, None, None]:
+        if isinstance(executor_type, str):
+            executor_type = ExecutorType(executor_type)
+        if executor_type not in self._executor_map:
+            raise ValueError(
+                f"Unsupported executor kind: {executor_type}. "
+                f"Supported kinds: {list(self._executor_map.keys())}"
+            )
+        executor = self._executor_map[executor_type]
+        yield from executor.execute_stream(workflow_id, version, input_data, user_config)
+

alayaflow/execution/executors/__init__.py

@@ -0,0 +1,9 @@
+"""Executor implementations for workflow execution."""
+
+from alayaflow.execution.executors.base_executor import BaseExecutor
+from alayaflow.execution.executors.uv_executor import UvExecutor
+from alayaflow.execution.executors.naive_executor import NaiveExecutor
+from alayaflow.execution.executors.worker_executor import WorkerExecutor
+
+__all__ = ["BaseExecutor", "UvExecutor", "NaiveExecutor", "WorkerExecutor"]
+

alayaflow/execution/executors/base_executor.py

@@ -0,0 +1,9 @@
+from abc import ABC, abstractmethod
+from typing import Generator, Dict
+
+
+class BaseExecutor(ABC):
+    @abstractmethod
+    def execute_stream(self, workflow_id: str, version: str, input_data: dict, config: dict) -> Generator[Dict, None, None]:
+        pass
+