flowllm 0.1.0__py3-none-any.whl → 0.1.2__py3-none-any.whl

flowllm/flow/parser/expression_parser.py

@@ -0,0 +1,171 @@
+import re
+
+from flowllm.context.service_context import C
+from flowllm.op.base_op import BaseOp
+from flowllm.op.parallel_op import ParallelOp
+from flowllm.op.sequential_op import SequentialOp
+from flowllm.schema.service_config import OpConfig
+
+
+class ExpressionParser:
+    SEQ_SYMBOL = ">>"
+    PARALLEL_SYMBOL = "|"
+
+    """
+    Simple flow implementation that supports parsing operation expressions.
+
+    Supports flow expressions like:
+    - "op1 >> op2" (sequential expressions)
+    - "op1 | op2" (parallel expressions)  
+    - "op1 >> (op2 | op3) >> op4" (mixed expressions)
+    - "op1 >> (op1 | (op2 >> op3)) >> op4" (complex nested expressions)
+    """
+
+    def __init__(self, flow_content: str = ""):
+        self.flow_content: str = flow_content
+        self._parsed_ops_cache = {}
+
+    def parse_flow(self):
+        self._parsed_ops_cache.clear()
+        expression = re.sub(r'\s+', ' ', self.flow_content.strip())
+        return self._parse_expression(expression)
+
+    def _parse_expression(self, expression: str) -> BaseOp:
+        """
+        Parse the flow content string into executable operations.
+
+        Supports expressions with operators:
+        - ">>" for sequential execution
+        - "|" for parallel execution
+        - Parentheses for grouping operations
+
+        Args:
+            expression: The expression string to parse. If None, uses self.flow_content
+
+        Returns:
+            BaseOp: The parsed flow as an executable operation tree
+        """
+        # handle parentheses by finding and replacing innermost groups
+        while '(' in expression:
+            # Find the innermost parentheses
+            start = -1
+            for i, char in enumerate(expression):
+                if char == '(':
+                    start = i
+                elif char == ')':
+                    if start == -1:
+                        raise ValueError(f"mismatched parentheses in expression: {expression}")
+
+                    # extract and parse the inner expression
+                    inner_expr = expression[start + 1:i]
+                    inner_result = self._parse_expression(inner_expr)
+
+                    # create a placeholder for the parsed inner expression
+                    placeholder = f"__PARSED_OP_{len(self._parsed_ops_cache)}__"
+
+                    # store the parsed operation for later retrieval
+                    self._parsed_ops_cache[placeholder] = inner_result
+
+                    # Replace the parentheses group with placeholder
+                    expression = expression[:start] + placeholder + expression[i + 1:]
+                    break
+            else:
+                if start != -1:
+                    raise ValueError(f"mismatched parentheses in expression: {expression}")
+
+        # Parse the expression without parentheses
+        return self._parse_flat_expression(expression)
+
+    def _parse_flat_expression(self, expression: str) -> BaseOp:
+        """
+        Parse a flat expression (no parentheses) into operation objects.
+
+        Args:
+            expression: The flat expression string
+
+        Returns:
+            BaseOp: The parsed operation tree
+        """
+        # split by '>>' first (sequential has higher precedence)
+        sequential_parts = [part.strip() for part in expression.split(self.SEQ_SYMBOL)]
+
+        if len(sequential_parts) > 1:
+            # parse each part and create sequential operation
+            ops = []
+            for part in sequential_parts:
+                part = part.strip()
+                if part in self._parsed_ops_cache:
+                    ops.append(self._parsed_ops_cache[part])
+                else:
+                    ops.append(self._parse_parallel_expression(part))
+
+            return SequentialOp(ops=ops)
+
+        else:
+            # no sequential operators, parse for parallel
+            return self._parse_parallel_expression(expression)
+
+    def _parse_parallel_expression(self, expression: str) -> BaseOp:
+        """
+        Parse a parallel expression (operations separated by |).
+
+        Args:
+            expression: The expression string
+
+        Returns:
+            BaseOp: The parsed operation (single op or parallel op)
+        """
+        parallel_parts = [part.strip() for part in expression.split(self.PARALLEL_SYMBOL)]
+
+        if len(parallel_parts) > 1:
+            # create parallel operation
+            ops = []
+            for part in parallel_parts:
+                part = part.strip()
+                if part in self._parsed_ops_cache:
+                    ops.append(self._parsed_ops_cache[part])
+                else:
+                    ops.append(self._create_op(part))
+
+            return ParallelOp(ops=ops)
+
+        else:
+            # single operation
+            part = expression.strip()
+            if part in self._parsed_ops_cache:
+                return self._parsed_ops_cache[part]
+            else:
+                return self._create_op(part)
+
+    @staticmethod
+    def _create_op(op_name: str) -> BaseOp:
+        if op_name in C.service_config.op:
+            op_config: OpConfig = C.service_config.op[op_name]
+            op_cls = C.resolve_op(op_config.backend)
+
+
+        elif op_name in C.registry_dict["op"]:
+            op_config: OpConfig = OpConfig()
+            op_cls = C.resolve_op(op_name)
+
+        else:
+            raise ValueError(f"op='{op_name}' is not registered!")
+
+        kwargs = {
+            "name": op_name,
+            "raise_exception": op_config.raise_exception,
+            **op_config.params
+        }
+
+        if op_config.language:
+            kwargs["language"] = op_config.language
+        if op_config.prompt_path:
+            kwargs["prompt_path"] = op_config.prompt_path
+        if op_config.llm:
+            kwargs["llm"] = op_config.llm
+        if op_config.embedding_model:
+            kwargs["embedding_model"] = op_config.embedding_model
+        if op_config.vector_store:
+            kwargs["vector_store"] = op_config.vector_store
+
+        return op_cls(**kwargs)

flowllm/llm/__init__.py

@@ -0,0 +1,2 @@
+from .litellm_llm import LiteLLMBaseLLM
+from .openai_compatible_llm import OpenAICompatibleBaseLLM

{llmflow → flowllm}/llm/base_llm.py

@@ -1,12 +1,13 @@
+import asyncio
 import time
 from abc import ABC
-from typing import List, Literal, Callable
+from typing import List, Callable
 
 from loguru import logger
 from pydantic import Field, BaseModel
 
-from llmflow.schema.message import Message
-from llmflow.tool.base_tool import BaseTool
+from flowllm.schema.message import Message
+from flowllm.schema.tool_call import ToolCall
 
 
 class BaseLLM(BaseModel, ABC):
@@ -28,19 +29,19 @@ class BaseLLM(BaseModel, ABC):
     stream_options: dict = Field(default={"include_usage": True}, description="Options for streaming responses")
     temperature: float = Field(default=0.0000001, description="Sampling temperature (low for deterministic outputs)")
     presence_penalty: float | None = Field(default=None, description="Presence penalty to reduce repetition")
-    
+
     # Model-specific features
-    enable_thinking: bool = Field(default=True, description="Enable reasoning/thinking mode for supported models")
-    
+    enable_thinking: bool = Field(default=False, description="Enable reasoning/thinking mode for supported models")
+
     # Tool usage configuration
-    tool_choice: Literal["none", "auto", "required"] = Field(default="auto", description="Strategy for tool selection")
+    tool_choice: str = Field(default=None, description="Strategy for tool selection")
     parallel_tool_calls: bool = Field(default=True, description="Allow multiple tool calls in parallel")
 
     # Error handling and reliability
     max_retries: int = Field(default=5, description="Maximum number of retry attempts on failure")
     raise_exception: bool = Field(default=False, description="Whether to raise exceptions or return default values")
 
-    def stream_chat(self, messages: List[Message], tools: List[BaseTool] = None, **kwargs):
+    def stream_chat(self, messages: List[Message], tools: List[ToolCall] = None, **kwargs):
         """
         Stream chat completions from the LLM.
         
@@ -57,21 +58,25 @@ class BaseLLM(BaseModel, ABC):
         """
         raise NotImplementedError
 
-    def stream_print(self, messages: List[Message], tools: List[BaseTool] = None, **kwargs):
+    async def astream_chat(self, messages: List[Message], tools: List[ToolCall] = None, **kwargs):
         """
-        Stream chat completions and print them to console in real-time.
+        Async stream chat completions from the LLM.
         
-        This is a convenience method for debugging and interactive use,
-        combining streaming with formatted console output.
+        This method should yield chunks of the response as they become available,
+        allowing for real-time display of the model's output in async contexts.
         
         Args:
             messages: List of conversation messages
             tools: Optional list of tools the model can use
             **kwargs: Additional model-specific parameters
+            
+        Yields:
+            Chunks of the streaming response with their types
         """
         raise NotImplementedError
 
-    def _chat(self, messages: List[Message], tools: List[BaseTool] = None, **kwargs) -> Message:
+    def _chat(self, messages: List[Message], tools: List[ToolCall] = None, enable_stream_print: bool = False,
+              **kwargs) -> Message:
         """
         Internal method to perform a single chat completion.
         
@@ -82,6 +87,7 @@ class BaseLLM(BaseModel, ABC):
         Args:
             messages: List of conversation messages
             tools: Optional list of tools the model can use
+            enable_stream_print: Whether to print streaming response to console
             **kwargs: Additional model-specific parameters
             
         Returns:
@@ -89,8 +95,28 @@ class BaseLLM(BaseModel, ABC):
         """
         raise NotImplementedError
 
-    def chat(self, messages: List[Message], tools: List[BaseTool] = None, callback_fn: Callable = None,
-             default_value=None, **kwargs):
+    async def _achat(self, messages: List[Message], tools: List[ToolCall] = None, enable_stream_print: bool = False,
+                     **kwargs) -> Message:
+        """
+        Internal async method to perform a single chat completion.
+        
+        This method should be implemented by subclasses to handle the actual
+        async communication with the LLM provider. It's called by the public achat()
+        method which adds retry logic and error handling.
+        
+        Args:
+            messages: List of conversation messages
+            tools: Optional list of tools the model can use
+            enable_stream_print: Whether to print streaming response to console
+            **kwargs: Additional model-specific parameters
+            
+        Returns:
+            The complete response message from the LLM
+        """
+        raise NotImplementedError
+
+    def chat(self, messages: List[Message], tools: List[ToolCall] = None, enable_stream_print: bool = False,
+             callback_fn: Callable = None, default_value=None, **kwargs):
         """
         Perform a chat completion with retry logic and error handling.
         
@@ -103,6 +129,7 @@ class BaseLLM(BaseModel, ABC):
             tools: Optional list of tools the model can use
             callback_fn: Optional callback to process the response message
             default_value: Value to return if all retries fail (when raise_exception=False)
+            enable_stream_print: Whether to print streaming response to console
             **kwargs: Additional model-specific parameters
             
         Returns:
@@ -114,8 +141,11 @@ class BaseLLM(BaseModel, ABC):
         for i in range(self.max_retries):
             try:
                 # Attempt to get response from the model
-                message: Message = self._chat(messages, tools, **kwargs)
-                
+                message: Message = self._chat(messages=messages,
+                                              tools=tools,
+                                              enable_stream_print=enable_stream_print,
+                                              **kwargs)
+
                 # Apply callback function if provided
                 if callback_fn:
                     return callback_fn(message)
@@ -124,7 +154,7 @@ class BaseLLM(BaseModel, ABC):
 
             except Exception as e:
                 logger.exception(f"chat with model={self.model_name} encounter error with e={e.args}")
-                
+
                 # Exponential backoff: wait longer after each failure
                 time.sleep(1 + i)
 
@@ -136,3 +166,55 @@ class BaseLLM(BaseModel, ABC):
                         return default_value
 
         return None
+
+    async def achat(self, messages: List[Message], tools: List[ToolCall] = None, enable_stream_print: bool = False,
+                    callback_fn: Callable = None, default_value=None, **kwargs):
+        """
+        Perform an async chat completion with retry logic and error handling.
+        
+        This is the main public interface for async chat completions. It wraps the
+        internal _achat() method with robust error handling, exponential backoff,
+        and optional callback processing.
+        
+        Args:
+            messages: List of conversation messages
+            tools: Optional list of tools the model can use
+            callback_fn: Optional callback to process the response message
+            default_value: Value to return if all retries fail (when raise_exception=False)
+            enable_stream_print: Whether to print streaming response to console
+            **kwargs: Additional model-specific parameters
+            
+        Returns:
+            The response message (possibly processed by callback_fn) or default_value
+            
+        Raises:
+            Exception: If raise_exception=True and all retries fail
+        """
+        for i in range(self.max_retries):
+            try:
+                # Attempt to get response from the model
+                message: Message = await self._achat(messages=messages,
+                                                     tools=tools,
+                                                     enable_stream_print=enable_stream_print,
+                                                     **kwargs)
+
+                # Apply callback function if provided
+                if callback_fn:
+                    return callback_fn(message)
+                else:
+                    return message
+
+            except Exception as e:
+                logger.exception(f"async chat with model={self.model_name} encounter error with e={e.args}")
+
+                # Exponential backoff: wait longer after each failure
+                await asyncio.sleep(1 + i)
+
+                # Handle final retry failure
+                if i == self.max_retries - 1:
+                    if self.raise_exception:
+                        raise e
+                    else:
+                        return default_value
+
+        return None