flowllm 0.1.3__py3-none-any.whl → 0.1.5__py3-none-any.whl

flowllm/op/base_ray_op.py

@@ -1,313 +0,0 @@
-from abc import ABC
-
-import pandas as pd
-import ray
-from loguru import logger
-from tqdm import tqdm
-
-from flowllm.context.service_context import C
-from flowllm.op.base_op import BaseOp
-
-
-class BaseRayOp(BaseOp, ABC):
-    """
-    Base class for Ray-based operations that provides parallel task execution capabilities.
-    Inherits from BaseOp and provides methods for submitting and joining Ray tasks.
-    """
-
-    def submit_and_join_ray_task(self, fn, parallel_key: str = "", task_desc: str = "",
-                                 enable_test: bool = False, **kwargs):
-        """
-        Submit multiple Ray tasks in parallel and wait for all results.
-        
-        This method automatically detects a list parameter to parallelize over, distributes
-        the work across multiple Ray workers, and returns the combined results.
-        
-        Args:
-            fn: Function to execute in parallel
-            parallel_key: Key of the parameter to parallelize over (auto-detected if empty)
-            task_desc: Description for logging and progress bars
-            enable_test: Enable test mode (prints results instead of executing)
-            **kwargs: Arguments to pass to the function, including the list to parallelize over
-        
-        Returns:
-            List of results from all parallel tasks
-        """
-        max_workers = C.service_config.ray_max_workers
-        self.ray_task_list.clear()
-
-        # Auto-detect parallel key if not provided
-        if not parallel_key:
-            for key, value in kwargs.items():
-                if isinstance(value, list):
-                    parallel_key = key
-                    logger.info(f"using first list parallel_key={parallel_key}")
-                    break
-
-        # Extract the list to parallelize over
-        parallel_list = kwargs.pop(parallel_key)
-        assert isinstance(parallel_list, list)
-
-        # Convert pandas DataFrames to Ray objects for efficient sharing
-        for key in sorted(kwargs.keys()):
-            value = kwargs[key]
-            if isinstance(value, pd.DataFrame):
-                kwargs[key] = ray.put(value)
-
-        if enable_test:
-            test_result_list = []
-            for value in parallel_list:
-                kwargs.update({"actor_index": 0, parallel_key: value})
-                t_result = fn(**kwargs)
-                if t_result:
-                    if isinstance(t_result, list):
-                        test_result_list.extend(t_result)
-                    else:
-                        test_result_list.append(t_result)
-            return test_result_list
-
-        # Create and submit tasks for each worker
-        for i in range(max_workers):
-            def fn_wrapper():
-                result_list = []
-                # Distribute work using stride: worker i-th processes items [i, i+max_workers, i+2*max_workers, ...]
-                for parallel_value in parallel_list[i::max_workers]:
-                    kwargs.update({
-                        "actor_index": i,
-                        parallel_key: parallel_value,
-                    })
-                    part_result = fn(**kwargs)
-                    if part_result:
-                        if isinstance(part_result, list):
-                            result_list.extend(part_result)
-                        else:
-                            result_list.append(part_result)
-                return result_list
-
-            self.submit_ray_task(fn=fn_wrapper)
-            logger.info(f"ray.submit task_desc={task_desc} id={i}")
-
-        # Wait for all tasks to complete and collect results
-        result = self.join_ray_task(task_desc=task_desc)
-        logger.info(f"{task_desc} complete. result_size={len(result)} resources={ray.available_resources()}")
-        return result
-
-    def submit_ray_task(self, fn, *args, **kwargs):
-        """
-        Submit a single Ray task for asynchronous execution.
-        
-        Args:
-            fn: Function to execute remotely
-            *args: Positional arguments for the function
-            **kwargs: Keyword arguments for the function
-        
-        Returns:
-            Self for method chaining
-        
-        Raises:
-            RuntimeError: If Ray is not configured (ray_max_workers <= 1)
-        """
-        if C.service_config.ray_max_workers <= 1:
-            raise RuntimeError("Ray is not configured. Please set ray_max_workers > 1 in service config.")
-
-        # Initialize Ray if not already done
-        if not ray.is_initialized():
-            logger.warning(f"Ray is not initialized. Initializing Ray with {C.service_config.ray_max_workers} workers.")
-            ray.init(num_cpus=C.service_config.ray_max_workers)
-
-        # Create remote function and submit task
-        remote_fn = ray.remote(fn)
-        task = remote_fn.remote(*args, **kwargs)
-        self.ray_task_list.append(task)
-        return self
-
-    def join_ray_task(self, task_desc: str = None) -> list:
-        """
-        Wait for all submitted Ray tasks to complete and collect their results.
-        
-        Args:
-            task_desc: Description for the progress bar
-            
-        Returns:
-            Combined list of results from all completed tasks
-        """
-        result = []
-        # Process each task and collect results with progress bar
-        for task in tqdm(self.ray_task_list, desc=task_desc or f"{self.name}_ray"):
-            t_result = ray.get(task)
-            if t_result:
-                if isinstance(t_result, list):
-                    result.extend(t_result)
-                else:
-                    result.append(t_result)
-        self.ray_task_list.clear()
-        return result
-
-
-def run():
-    """Test Ray multiprocessing functionality"""
-    import time
-    import math
-
-    # CPU intensive task for testing
-    def cpu_intensive_task(n: int, task_id: str):
-        """CPU intensive task: calculate prime numbers"""
-        start_t = time.time()
-
-        def is_prime(num):
-            if num < 2:
-                return False
-            for j in range(2, int(math.sqrt(num)) + 1):
-                if num % j == 0:
-                    return False
-            return True
-
-        primes = [x for x in range(2, n) if is_prime(x)]
-        end_t = time.time()
-
-        result = {
-            'task_id': task_id,
-            'prime_count': len(primes),
-            'max_prime': max(primes) if primes else 0,
-            'execution_time': end_t - start_t
-        }
-        logger.info(f"Task {task_id} completed: found {len(primes)} primes, time: {result['execution_time']:.2f}s")
-        return result
-
-    class TestRayOp(BaseRayOp):
-        def execute(self):
-            logger.info(f"Executing {self.name}")
-            return f"Result from {self.name}"
-
-    # Initialize service config for Ray
-    from flowllm.schema.service_config import ServiceConfig
-
-    # Create a test service config with Ray enabled
-    test_config = ServiceConfig()
-    test_config.ray_max_workers = 4  # Enable Ray with 4 workers
-    test_config.thread_pool_max_workers = 4
-
-    # Set the service config
-    C.init_by_service_config(test_config)
-
-    logger.info("=== Testing Ray multiprocessing ===")
-
-    # Create test operation
-    ray_op = TestRayOp("ray_test_op")
-
-    logger.info("--- Testing submit_ray_task and join_ray_task ---")
-
-    # Test 1: Basic Ray task submission
-    task_size = 50000  # Find primes up to 50000 (more CPU intensive)
-    num_tasks = 4
-
-    try:
-        # Submit multiple CPU-intensive tasks
-
-        logger.info(f"Submitting {num_tasks} Ray tasks (finding primes up to {task_size})")
-        start_time = time.time()
-
-        for i in range(num_tasks):
-            ray_op.submit_ray_task(cpu_intensive_task, task_size, f"ray_task_{i}")
-
-        # Wait for all tasks to complete
-        results = ray_op.join_ray_task("Processing Ray tasks")
-        end_time = time.time()
-
-        logger.info(f"Ray tasks completed in {end_time - start_time:.2f}s")
-        logger.info(f"Ray results: {results}")
-
-    except Exception as e:
-        logger.error(f"Ray task execution failed: {e}")
-
-    # Test 2: Compare Ray vs ThreadPool performance
-    logger.info("\n--- Performance Comparison: Ray vs ThreadPool ---")
-
-    try:
-        # Test with ThreadPool
-        thread_op = TestRayOp("thread_test_op")
-
-        logger.info(f"Testing ThreadPool with {num_tasks} tasks")
-        start_time = time.time()
-
-        for i in range(num_tasks):
-            thread_op.submit_task(cpu_intensive_task, task_size, f"thread_task_{i}")
-
-        thread_results = thread_op.join_task("Processing ThreadPool tasks")
-        print(thread_results)
-        thread_time = time.time() - start_time
-
-        logger.info(f"ThreadPool completed in {thread_time:.2f}s")
-
-        # Test with Ray again for comparison
-        ray_op2 = TestRayOp("ray_test_op2")
-
-        logger.info(f"Testing Ray with {num_tasks} tasks")
-        start_time = time.time()
-
-        for i in range(num_tasks):
-            ray_op2.submit_ray_task(cpu_intensive_task, task_size, f"ray_task2_{i}")
-
-        ray_results2 = ray_op2.join_ray_task("Processing Ray tasks (comparison)")
-        print(ray_results2)
-        ray_time = time.time() - start_time
-
-        logger.info(f"Ray completed in {ray_time:.2f}s")
-
-        # Performance comparison
-        speedup = thread_time / ray_time if ray_time > 0 else 0
-        logger.info(f"\n=== Performance Summary ===")
-        logger.info(f"ThreadPool time: {thread_time:.2f}s")
-        logger.info(f"Ray time: {ray_time:.2f}s")
-        logger.info(f"Ray speedup: {speedup:.2f}x")
-
-    except Exception as e:
-        logger.error(f"Performance comparison failed: {e}")
-
-    # Test 3: Error handling
-    logger.info("\n--- Testing Error Handling ---")
-
-    def failing_task(task_id: str):
-        if task_id == "fail_task":
-            raise ValueError(f"Intentional error in {task_id}")
-        return f"Success: {task_id}"
-
-    try:
-        error_op = TestRayOp("error_test_op")
-
-        # Submit mix of successful and failing tasks
-        error_op.submit_ray_task(failing_task, "success_task_1")
-        error_op.submit_ray_task(failing_task, "fail_task")
-        error_op.submit_ray_task(failing_task, "success_task_2")
-
-        error_results = error_op.join_ray_task("Testing error handling")
-        logger.info(f"Error handling results: {error_results}")
-
-    except Exception as e:
-        logger.error(f"Expected error occurred: {e}")
-
-    # Test 4: Ray without proper configuration (should fail)
-    logger.info("\n--- Testing Ray Configuration Validation ---")
-
-    original_workers = C.service_config.ray_max_workers
-    try:
-        # Temporarily disable Ray in config
-        C.service_config.ray_max_workers = 1  # Disable Ray
-
-        config_test_op = TestRayOp("config_test_op")
-        config_test_op.submit_ray_task(cpu_intensive_task, 100, "config_test")
-
-        logger.error("This should not be reached - Ray should be disabled")
-
-    except RuntimeError as e:
-        logger.info(f"✓ Correctly caught configuration error: {e}")
-
-    finally:
-        # Restore original configuration
-        C.service_config.ray_max_workers = original_workers
-
-    logger.info("\n=== Ray testing completed ===")
-
-
-if __name__ == "__main__":
-    run()

flowllm/op/code/__init__.py

@@ -1 +0,0 @@
-from .execute_code_op import ExecuteCodeOp

flowllm/op/code/execute_code_op.py

@@ -1,42 +0,0 @@
-import sys
-from io import StringIO
-
-from loguru import logger
-
-from flowllm.context.flow_context import FlowContext
-from flowllm.context.service_context import C
-from flowllm.op.base_op import BaseOp
-
-
-@C.register_op()
-class ExecuteCodeOp(BaseOp):
-
-    def execute(self):
-        old_stdout = sys.stdout
-        redirected_output = sys.stdout = StringIO()
-
-        try:
-            code_key: str = self.op_params.get("code_key", "code")
-            code_str: str = self.context[code_key]
-            exec(code_str)
-            code_result = redirected_output.getvalue()
-
-        except Exception as e:
-            logger.info(f"{self.name} encounter exception! error={e.args}")
-            code_result = str(e)
-
-        sys.stdout = old_stdout
-        self.context.code_result = code_result
-
-
-if __name__ == "__main__":
-    C.set_default_service_config().init_by_service_config()
-    op = ExecuteCodeOp()
-
-    context = FlowContext(code="print('Hello World')")
-    op(context=context)
-    print(context.code_result)
-
-    context.code = "print('Hello World!'"
-    op(context=context)
-    print(context.code_result)

flowllm/op/gallery/terminate_op.py

@@ -1,29 +0,0 @@
-from flowllm.context.service_context import C
-from flowllm.op.base_op import BaseOp
-
-
-@C.register_op()
-class TerminateOp(BaseOp):
-
-    def execute(self):
-        # Get status from context
-        status = self.context.status
-        assert status in ["success", "failure"], f"Invalid status: {status}"
-        self.context.terminate_answer = f"The interaction has been completed with status: {status}"
-
-
-if __name__ == "__main__":
-    from flowllm.context.flow_context import FlowContext
-
-    C.set_default_service_config().init_by_service_config()
-
-    # Test success termination
-    op = TerminateOp()
-    context = FlowContext(status="success")
-    result = op(context=context)
-    print(f"Result: {context.terminate_answer}")
-
-    # Test failure termination
-    context.status = "failure"
-    op(context=context)
-    print(f"Result: {context.terminate_answer}")

flowllm/op/search/dashscope_deep_research_op.py

@@ -1,267 +0,0 @@
-import os
-
-import dashscope
-from loguru import logger
-
-from flowllm.context.flow_context import FlowContext
-from flowllm.context.service_context import C
-from flowllm.op.base_llm_op import BaseLLMOp
-from flowllm.storage.cache.data_cache import DataCache
-
-
-@C.register_op()
-class DashscopeDeepResearchOp(BaseLLMOp):
-    file_path: str = __file__
-
-    """
-    Dashscope deep research operation using Alibaba's Qwen-deep-research model.
-    
-    This operation performs deep research using Dashscope's Generation API with the 
-    qwen-deep-research model. It handles the multi-phase research process including
-    model questioning, web research, and result generation.
-    """
-
-    def __init__(self,
-                 model: str = "qwen-deep-research",
-                 enable_print: bool = True,
-                 enable_cache: bool = True,
-                 cache_path: str = "./dashscope_deep_research_cache",
-                 cache_expire_hours: float = 24,
-                 max_retries: int = 3,
-                 return_only_content: bool = True,
-                 **kwargs):
-        super().__init__(**kwargs)
-
-        self.model = model
-        self.enable_print = enable_print
-        self.enable_cache = enable_cache
-        self.cache_expire_hours = cache_expire_hours
-        self.max_retries = max_retries
-        self.return_only_content = return_only_content
-
-        # Ensure API key is available
-        self.api_key = os.environ["FLOW_DASHSCOPE_API_KEY"]
-        self.cache_path: str = cache_path
-        self._cache: DataCache | None = None
-
-    @property
-    def cache(self):
-        if self.enable_cache and self._cache is None:
-            self._cache = DataCache(self.cache_path)
-        return self._cache
-
-    def process_responses(self, responses, step_name):
-        """Process streaming responses from the deep research model"""
-        current_phase = None
-        phase_content = ""
-        research_goal = ""
-        web_sites = []
-        keepalive_shown = False  # 标记是否已经显示过KeepAlive提示
-
-        for response in responses:
-            # 检查响应状态码
-            if hasattr(response, 'status_code') and response.status_code != 200:
-                logger.warning(f"HTTP返回码：{response.status_code}")
-                if hasattr(response, 'code'):
-                    logger.warning(f"错误码：{response.code}")
-                if hasattr(response, 'message'):
-                    logger.warning(f"错误信息：{response.message}")
-                continue
-
-            if hasattr(response, 'output') and response.output:
-                message = response.output.get('message', {})
-                phase = message.get('phase')
-                content = message.get('content', '')
-                status = message.get('status')
-                extra = message.get('extra', {})
-
-                # 阶段变化检测
-                if phase != current_phase:
-                    if current_phase and phase_content:
-                        # 根据阶段名称和步骤名称来显示不同的完成描述
-                        if step_name == "第一步：模型反问确认" and current_phase == "answer":
-                            logger.info("模型反问阶段完成")
-                        else:
-                            logger.info(f"{current_phase} 阶段完成")
-                    current_phase = phase
-                    phase_content = ""
-                    keepalive_shown = False  # 重置KeepAlive提示标记
-
-                    # 根据阶段名称和步骤名称来显示不同的描述
-                    if step_name == "第一步：模型反问确认" and phase == "answer":
-                        logger.info("进入模型反问阶段")
-                    else:
-                        logger.info(f"进入 {phase} 阶段")
-
-                # 处理WebResearch阶段的特殊信息
-                if phase == "WebResearch":
-                    if extra.get('deep_research', {}).get('research'):
-                        research_info = extra['deep_research']['research']
-
-                        # 处理streamingQueries状态
-                        if status == "streamingQueries":
-                            if 'researchGoal' in research_info:
-                                goal = research_info['researchGoal']
-                                if goal:
-                                    research_goal += goal
-                                    if self.enable_print:
-                                        print(f"   研究目标: {goal}", end='', flush=True)
-
-                        # 处理streamingWebResult状态
-                        elif status == "streamingWebResult":
-                            if 'webSites' in research_info:
-                                sites = research_info['webSites']
-                                if sites and sites != web_sites:  # 避免重复显示
-                                    web_sites = sites
-                                    if self.enable_print:
-                                        print(f"   找到 {len(sites)} 个相关网站:")
-                                        for i, site in enumerate(sites, 1):
-                                            print(f"     {i}. {site.get('title', '无标题')}")
-                                            print(f"        描述: {site.get('description', '无描述')[:100]}...")
-                                            print(f"        URL: {site.get('url', '无链接')}")
-                                            if site.get('favicon'):
-                                                print(f"        图标: {site['favicon']}")
-                                            print()
-
-                        # 处理WebResultFinished状态
-                        elif status == "WebResultFinished":
-                            if self.enable_print:
-                                print(f"   网络搜索完成，共找到 {len(web_sites)} 个参考信息源")
-                                if research_goal:
-                                    print(f"   研究目标: {research_goal}")
-
-                # 累积内容并显示
-                if content:
-                    phase_content += content
-                    # 实时显示内容
-                    if self.enable_print:
-                        print(content, end='', flush=True)
-
-                # 显示阶段状态变化
-                if status and status != "typing":
-                    if self.enable_print:
-                        print(f"   状态: {status}")
-
-                    # 显示状态说明
-                    if status == "streamingQueries":
-                        if self.enable_print:
-                            print("   → 正在生成研究目标和搜索查询（WebResearch阶段）")
-                    elif status == "streamingWebResult":
-                        if self.enable_print:
-                            print("   → 正在执行搜索、网页阅读和代码执行（WebResearch阶段）")
-                    elif status == "WebResultFinished":
-                        if self.enable_print:
-                            print("   → 网络搜索阶段完成（WebResearch阶段）")
-
-                # 当状态为finished时，显示token消耗情况
-                if status == "finished":
-                    if hasattr(response, 'usage') and response.usage:
-                        usage = response.usage
-                        if self.enable_print:
-                            print(f"    Token消耗统计:")
-                            print(f"      输入tokens: {usage.get('input_tokens', 0)}")
-                            print(f"      输出tokens: {usage.get('output_tokens', 0)}")
-                            print(f"      请求ID: {response.get('request_id', '未知')}")
-
-                if phase == "KeepAlive":
-                    # 只在第一次进入KeepAlive阶段时显示提示
-                    if not keepalive_shown:
-                        if self.enable_print:
-                            print("当前步骤已经完成，准备开始下一步骤工作")
-                        keepalive_shown = True
-                    continue
-
-        if current_phase and phase_content:
-            if step_name == "第一步：模型反问确认" and current_phase == "answer":
-                logger.info("模型反问阶段完成")
-            else:
-                logger.info(f"{current_phase} 阶段完成")
-
-        return phase_content
-
-    def call_deep_research_model(self, messages, step_name):
-        """Call the deep research model with the given messages"""
-        if self.enable_print:
-            print(f"\n=== {step_name} ===")
-
-        try:
-            responses = dashscope.Generation.call(
-                api_key=self.api_key,
-                model=self.model,
-                messages=messages,
-                # qwen-deep-research模型目前仅支持流式输出
-                stream=True
-                # incremental_output=True 使用增量输出请添加此参数
-            )
-
-            return self.process_responses(responses, step_name)
-
-        except Exception as e:
-            logger.error(f"调用API时发生错误: {e}")
-            return ""
-
-    def execute(self):
-        """Execute the Dashscope deep research operation"""
-        # Get query from context
-        query = self.context.query
-
-        # Check cache first
-        if self.enable_cache and self.cache:
-            cached_result = self.cache.load(query)
-            if cached_result:
-                if self.return_only_content:
-                    self.context.dashscope_deep_research_result = cached_result.get("content", "")
-                else:
-                    self.context.dashscope_deep_research_result = cached_result
-                return
-
-        # 第一步：模型反问确认
-        # 模型会分析用户问题，提出细化问题来明确研究方向
-        messages = [{'role': 'user', 'content': query}]
-        step1_content = self.call_deep_research_model(messages, "第一步：模型反问确认")
-
-        # 第二步：深入研究
-        # 基于第一步的反问内容，模型会执行完整的研究流程
-        messages = [
-            {'role': 'user', 'content': query},
-            {'role': 'assistant', 'content': step1_content},  # 包含模型的反问内容
-            {'role': 'user', 'content': '帮我生成完整且逻辑性的报告'}
-        ]
-
-        result_content = self.call_deep_research_model(messages, "第二步：深入研究")
-
-        if self.enable_print:
-            print(result_content)
-            print("\n 研究完成！")
-
-        # Prepare final result
-        final_result = {
-            "query": query,
-            "step1_content": step1_content,
-            "final_result": result_content,
-            "model": self.model
-        }
-
-        # Cache the result if enabled
-        if self.enable_cache and self.cache:
-            self.cache.save(query, final_result, expire_hours=self.cache_expire_hours)
-
-        # Set context
-        if self.return_only_content:
-            self.context.dashscope_deep_research_result = result_content
-        else:
-            self.context.dashscope_deep_research_result = final_result
-
-
-def main():
-    C.set_default_service_config().init_by_service_config()
-
-    op = DashscopeDeepResearchOp(enable_print=True, enable_cache=True)
-
-    context = FlowContext(query="中国电解铝行业值得投资吗，有哪些值得投资的标的，各个标的之间需要对比优劣势")
-    op(context=context)
-    print(context.dashscope_deep_research_result)
-
-
-if __name__ == "__main__":
-    main()

flowllm/service/cmd_service.py

@@ -1,15 +0,0 @@
-from loguru import logger
-
-from flowllm.context.service_context import C
-from flowllm.flow.gallery import CmdFlow
-from flowllm.service.base_service import BaseService
-
-
-@C.register_service("cmd")
-class CmdService(BaseService):
-
-    def __call__(self):
-        flow = CmdFlow(flow=self.service_config.cmd.flow)
-        response = flow.__call__(**self.service_config.cmd.params)
-        if response.answer:
-            logger.info(f"final_answer={response.answer}")