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

flowllm/config/pydantic_config_parser.py

@@ -0,0 +1,242 @@
+import copy
+import json
+from pathlib import Path
+from typing import Any, Generic, List, Type, TypeVar
+
+import yaml
+from loguru import logger
+from pydantic import BaseModel
+
+T = TypeVar('T', bound=BaseModel)
+
+
+class PydanticConfigParser(Generic[T]):
+    current_file: str = __file__
+    default_config_name: str = ""
+
+    """
+    Pydantic Configuration Parser
+    
+    Supported configuration sources (priority from low to high):
+    1. Default configuration (Pydantic model default values)
+    2. YAML configuration file
+    3. Command line arguments (dot notation format)
+    4. Runtime parameters
+    """
+
+    def __init__(self, config_class: Type[T]):
+        """
+        Initialize configuration parser
+        
+        Args:
+            config_class: Pydantic configuration model class
+        """
+        self.config_class = config_class
+        self.config_dict: dict = {}
+
+    def parse_dot_notation(self, dot_list: List[str]) -> dict:
+        """
+        Parse dot notation format configuration list
+        
+        Args:
+            dot_list: Configuration list in format ['a.b.c=value', 'x.y=123']
+            
+        Returns:
+            Parsed nested dictionary
+        """
+        config_dict = {}
+
+        for item in dot_list:
+            if '=' not in item:
+                continue
+
+            key_path, value_str = item.split('=', 1)
+            keys = key_path.split('.')
+
+            # Automatic type conversion
+            value = self._convert_value(value_str)
+
+            # Build nested dictionary
+            current_dict = config_dict
+            for key in keys[:-1]:
+                if key not in current_dict:
+                    current_dict[key] = {}
+                current_dict = current_dict[key]
+
+            current_dict[keys[-1]] = value
+
+        return config_dict
+
+    @staticmethod
+    def _convert_value(value_str: str) -> Any:
+        """
+        Automatically convert string values to appropriate Python types
+        
+        Args:
+            value_str: String value
+            
+        Returns:
+            Converted value
+        """
+        value_str = value_str.strip()
+
+        if value_str.lower() in ("true", "false"):
+            return value_str.lower() == "true"
+
+        if value_str.lower() in ("none", "null"):
+            return None
+
+        try:
+            if "." not in value_str and "e" not in value_str.lower():
+                return int(value_str)
+
+            return float(value_str)
+
+        except ValueError:
+            pass
+
+        try:
+            return json.loads(value_str)
+        except (json.JSONDecodeError, ValueError):
+            pass
+
+        return value_str
+
+    @staticmethod
+    def load_from_yaml(yaml_path: str | Path) -> dict:
+        """
+        Load configuration from YAML file
+        
+        Args:
+            yaml_path: YAML file path
+            
+        Returns:
+            Configuration dictionary
+        """
+        if isinstance(yaml_path, str):
+            yaml_path = Path(yaml_path)
+
+        if not yaml_path.exists():
+            raise FileNotFoundError(f"Configuration file does not exist: {yaml_path}")
+
+        with yaml_path.open() as f:
+            return yaml.safe_load(f)
+
+    def merge_configs(self, *config_dicts: dict) -> dict:
+        """
+        Deep merge multiple configuration dictionaries
+        
+        Args:
+            *config_dicts: Multiple configuration dictionaries
+            
+        Returns:
+            Merged configuration dictionary
+        """
+        result = {}
+
+        for config_dict in config_dicts:
+            result = self._deep_merge(result, config_dict)
+
+        return result
+
+    def _deep_merge(self, base_dict: dict, update_dict: dict) -> dict:
+        """
+        Deep merge two dictionaries
+        
+        Args:
+            base_dict: Base dictionary
+            update_dict: Update dictionary
+            
+        Returns:
+            Merged dictionary
+        """
+        result = base_dict.copy()
+
+        for key, value in update_dict.items():
+            if key in result and isinstance(result[key], dict) and isinstance(value, dict):
+                result[key] = self._deep_merge(result[key], value)
+            else:
+                result[key] = value
+
+        return result
+
+    def parse_args(self, *args) -> T:
+        """
+        Parse command line arguments and return configuration object
+        
+        Args:
+            args: Command line arguments.
+            
+        Returns:
+            Parsed configuration object
+        """
+        configs_to_merge = []
+
+        # 1. Default configuration (from Pydantic model)
+        default_config = self.config_class().model_dump()
+        configs_to_merge.append(default_config)
+
+        # 2. YAML configuration file
+        config = ""
+        filter_args = []
+        for arg in args:
+            if "=" not in arg:
+                continue
+
+            arg = arg.lstrip("--").lstrip("-")
+
+            if "c=" in arg or "config=" in arg:
+                config = arg.split("=")[-1]
+            else:
+                filter_args.append(arg)
+
+        if not config:
+            if self.default_config_name:
+                config = self.default_config_name
+            assert config, "add `config=<config_file>` in cmd!"
+
+        if not config.endswith(".yaml"):
+            config += ".yaml"
+
+        # load pre-built configs
+        config_path = Path(self.current_file).parent / config
+        if not config_path.exists():
+            config_path = Path(config)
+
+        yaml_config = self.load_from_yaml(config_path)
+        logger.info(f"flowllm using config={config_path}")
+        configs_to_merge.append(yaml_config)
+
+        # 3. Command line override configuration
+        if args:
+            cli_config = self.parse_dot_notation(filter_args)
+            configs_to_merge.append(cli_config)
+
+        # Merge all configurations
+        self.config_dict = self.merge_configs(*configs_to_merge)
+
+        # Create and validate final configuration object
+        return self.config_class.model_validate(self.config_dict)
+
+    def update_config(self, **kwargs) -> T:
+        """
+        Update configuration object using keyword arguments
+        
+        Args:
+            **kwargs: Configuration items to update, supports dot notation, e.g. server__host='localhost'
+            
+        Returns:
+            Updated configuration object
+        """
+        # Convert kwargs to dot notation format
+        dot_list = []
+        for key, value in kwargs.items():
+            # support double underscore as dot replacement (server__host -> server.host)
+            dot_key = key.replace("__", ".")
+            dot_list.append(f"{dot_key}={value}")
+
+        # Parse and merge configuration
+        override_config = self.parse_dot_notation(dot_list)
+        final_config = self.merge_configs(copy.deepcopy(self.config_dict), override_config)
+
+        return self.config_class.model_validate(final_config)

flowllm/context/base_context.py

@@ -0,0 +1,79 @@
+class BaseContext:
+    def __init__(self, **kwargs):
+        self._data = {**kwargs}
+
+    def __getattr__(self, name: str):
+        # Avoid infinite recursion when _data is not yet initialized
+        if name == '_data':
+            raise AttributeError(f"'{self.__class__.__name__}' has no attribute '{name}'")
+        
+        # Use object.__getattribute__ to safely access _data
+        try:
+            data = object.__getattribute__(self, '_data')
+        except AttributeError:
+            raise AttributeError(f"'{self.__class__.__name__}' has no attribute '{name}'")
+            
+        if name in data:
+            return data[name]
+
+        raise AttributeError(f"'{self.__class__.__name__}' has no attribute '{name}'")
+
+    def __setattr__(self, name: str, value):
+        if name == "_data":
+            super().__setattr__(name, value)
+        else:
+            self._data[name] = value
+
+    def __getitem__(self, name: str):
+        if name not in self._data:
+            raise AttributeError(f"'{self.__class__.__name__}' has no attribute '{name}'")
+        return self._data[name]
+
+    def __setitem__(self, name: str, value):
+        self._data[name] = value
+
+    def __contains__(self, name: str):
+        return name in self._data
+
+    def __repr__(self):
+        return f"{self.__class__.__name__}({self._data!r})"
+
+    def dump(self) -> dict:
+        return self._data
+
+    def get(self, key: str, default=None):
+        return self._data.get(key, default)
+
+    @property
+    def keys(self):
+        return self._data.keys()
+
+    def update(self, **kwargs):
+        self._data.update(kwargs)
+
+    def items(self):
+        return self._data.items()
+
+    def __getstate__(self):
+        """Support for pickle serialization"""
+        return {'_data': self._data}
+    
+    def __setstate__(self, state):
+        """Support for pickle deserialization"""
+        self._data = state['_data']
+
+if __name__ == "__main__":
+    ctx = BaseContext(**{"name": "Alice", "age": 30, "city": "New York"})
+
+    print(ctx.name)
+    print(ctx.age)
+    print(ctx.city)
+
+    ctx.email = "alice@example.com"
+    ctx["email"] = "alice@example.com"
+    print(ctx.email)
+
+    print(ctx.keys)
+    print(ctx)
+
+    # print(ctx.city2)

flowllm/context/flow_context.py

@@ -0,0 +1,16 @@
+import uuid
+
+from flowllm.context.base_context import BaseContext
+from flowllm.schema.flow_response import FlowResponse
+
+
+class FlowContext(BaseContext):
+
+    def __init__(self,
+                 flow_id: str = uuid.uuid4().hex,
+                 response: FlowResponse = None,
+                 **kwargs):
+        super().__init__(**kwargs)
+
+        self.flow_id: str = flow_id
+        self.response: FlowResponse = FlowResponse() if response is None else response

llmflow/op/prompt_mixin.py → flowllm/context/prompt_handler.py

@@ -3,42 +3,56 @@ from pathlib import Path
 import yaml
 from loguru import logger
 
+from flowllm.context.base_context import BaseContext
+from flowllm.context.service_context import C
 
-class PromptMixin:
 
-    def __init__(self):
-        self._prompt_dict: dict = {}
+class PromptHandler(BaseContext):
+
+    def __init__(self, language: str = "", **kwargs):
+        super().__init__(**kwargs)
+        self.language: str = language or C.language
 
     def load_prompt_by_file(self, prompt_file_path: Path | str = None):
         if prompt_file_path is None:
-            return
+            return self
 
         if isinstance(prompt_file_path, str):
             prompt_file_path = Path(prompt_file_path)
 
         if not prompt_file_path.exists():
-            return
+            return self
 
         with prompt_file_path.open() as f:
             prompt_dict = yaml.load(f, yaml.FullLoader)
             self.load_prompt_dict(prompt_dict)
+        return self
 
     def load_prompt_dict(self, prompt_dict: dict = None):
         if not prompt_dict:
-            return
+            return self
 
         for key, value in prompt_dict.items():
             if isinstance(value, str):
-                if key in self._prompt_dict:
-                    self._prompt_dict[key] = value
+                if key in self._data:
+                    self._data[key] = value
                     logger.warning(f"prompt_dict key={key} overwrite!")
 
                 else:
-                    self._prompt_dict[key] = value
+                    self._data[key] = value
                     logger.info(f"add prompt_dict key={key}")
+        return self
+
+    def get_prompt(self, prompt_name: str):
+        key: str = prompt_name
+        if self.language and not key.endswith(self.language.strip()):
+            key += "_" + self.language.strip()
 
-    def prompt_format(self, prompt_name: str, **kwargs):
-        prompt = self._prompt_dict[prompt_name]
+        assert key in self._data, f"prompt_name={key} not found."
+        return self._data[key]
+
+    def prompt_format(self, prompt_name: str, **kwargs) -> str:
+        prompt = self.get_prompt(prompt_name)
 
         flag_kwargs = {k: v for k, v in kwargs.items() if isinstance(v, bool)}
         other_kwargs = {k: v for k, v in kwargs.items() if not isinstance(v, bool)}
@@ -69,6 +83,3 @@ class PromptMixin:
             prompt = prompt.format(**other_kwargs)
 
         return prompt
-
-    def get_prompt(self, key: str):
-        return self._prompt_dict[key]

flowllm/context/registry.py

@@ -0,0 +1,30 @@
+from loguru import logger
+
+from flowllm.context.base_context import BaseContext
+from flowllm.utils.common_utils import camel_to_snake
+
+
+class Registry(BaseContext):
+
+    def __init__(self, registry_name: str, enable_log: bool = True, register_flow_module: bool = True, **kwargs):
+        super().__init__(**kwargs)
+        self.registry_name: str = registry_name
+        self.enable_log: bool = enable_log
+        self.register_flow_module: bool = register_flow_module
+
+    def register(self, name: str = ""):
+        def decorator(cls):
+            if not self.register_flow_module and cls.__module__.startswith("flowllm"):
+                return cls
+
+            class_name = name if name else camel_to_snake(cls.__name__)
+            if self.enable_log:
+                if class_name in self._data:
+                    logger.warning(f"{self.registry_name}.class({class_name}) is already registered!")
+                else:
+                    logger.info(f"{self.registry_name}.class({class_name}) is registered.")
+
+            self._data[class_name] = cls
+            return cls
+
+        return decorator

flowllm/context/service_context.py

@@ -0,0 +1,147 @@
+import os
+import uuid
+from concurrent.futures import ThreadPoolExecutor
+from inspect import isclass
+from typing import Dict, List
+
+import ray
+from loguru import logger
+
+from flowllm.context.base_context import BaseContext
+from flowllm.context.registry import Registry
+from flowllm.schema.service_config import ServiceConfig, EmbeddingModelConfig
+from flowllm.utils.singleton import singleton
+
+
+@singleton
+class ServiceContext(BaseContext):
+
+    def __init__(self, service_id: str = uuid.uuid4().hex, **kwargs):
+        super().__init__(**kwargs)
+
+        self.service_id: str = service_id
+        self.service_config: ServiceConfig | None = None
+        self.language: str = ""
+        self.thread_pool: ThreadPoolExecutor | None = None
+        self.vector_store_dict: dict = {}
+
+        self.registry_dict: Dict[str, Registry] = {}
+        use_framework: bool = os.environ.get("FLOW_USE_FRAMEWORK", "").lower() == "true"
+        for key in ["embedding_model", "llm", "vector_store", "op", "tool_flow", "service"]:
+            enable_log = True
+            register_flow_module = True
+
+            if use_framework:
+                enable_log = False
+                if key in ["op", "tool_flow"]:
+                    register_flow_module = False
+            self.registry_dict[key] = Registry(key, enable_log=enable_log, register_flow_module=register_flow_module)
+
+        self.tool_flow_dict: dict = {}
+
+    def set_default_service_config(self):
+        from flowllm.config.pydantic_config_parser import PydanticConfigParser
+
+        config_parser = PydanticConfigParser(ServiceConfig)
+        self.service_config = config_parser.parse_args("config=default")
+        return self
+
+    def init_by_service_config(self, service_config: ServiceConfig = None):
+        if service_config:
+            self.service_config = service_config
+
+        self.language = self.service_config.language
+        self.thread_pool = ThreadPoolExecutor(max_workers=self.service_config.thread_pool_max_workers)
+        if self.service_config.ray_max_workers > 1:
+            ray.init(num_cpus=self.service_config.ray_max_workers)
+
+        # add vector store
+        for name, config in self.service_config.vector_store.items():
+            vector_store_cls = self.resolve_vector_store(config.backend)
+            embedding_model_config: EmbeddingModelConfig = self.service_config.embedding_model[config.embedding_model]
+            embedding_model_cls = self.resolve_embedding_model(embedding_model_config.backend)
+            embedding_model = embedding_model_cls(model_name=embedding_model_config.model_name,
+                                                  **embedding_model_config.params)
+            self.vector_store_dict[name] = vector_store_cls(embedding_model=embedding_model, **config.params)
+
+        from flowllm.flow.base_tool_flow import BaseToolFlow
+        from flowllm.flow.gallery import ExpressionToolFlow
+
+        # add tool flow cls
+        for name, tool_flow_cls in self.registry_dict["tool_flow"].items():
+            if not isclass(tool_flow_cls):
+                continue
+
+            tool_flow: BaseToolFlow = tool_flow_cls()
+            self.tool_flow_dict[tool_flow.name] = tool_flow
+            logger.info(f"add diy tool_flow: {tool_flow.name}")
+
+        # add tool flow config
+        for name, flow_config in self.service_config.flow.items():
+            flow_config.name = name
+            tool_flow: BaseToolFlow = ExpressionToolFlow(flow_config=flow_config)
+            self.tool_flow_dict[tool_flow.name] = tool_flow
+            logger.info(f"add expression tool_flow:{tool_flow.name}")
+
+    def get_vector_store(self, name: str = "default"):
+        return self.vector_store_dict[name]
+
+    def get_tool_flow(self, name: str = "default"):
+        return self.tool_flow_dict[name]
+
+    @property
+    def tool_flow_names(self) -> List[str]:
+        return sorted(self.tool_flow_dict.keys())
+
+    """
+    register models
+    """
+
+    def register_embedding_model(self, name: str = ""):
+        return self.registry_dict["embedding_model"].register(name=name)
+
+    def register_llm(self, name: str = ""):
+        return self.registry_dict["llm"].register(name=name)
+
+    def register_vector_store(self, name: str = ""):
+        return self.registry_dict["vector_store"].register(name=name)
+
+    def register_op(self, name: str = ""):
+        return self.registry_dict["op"].register(name=name)
+
+    def register_tool_flow(self, name: str = ""):
+        return self.registry_dict["tool_flow"].register(name=name)
+
+    def register_service(self, name: str = ""):
+        return self.registry_dict["service"].register(name=name)
+
+    """
+    resolve models
+    """
+
+    def resolve_embedding_model(self, name: str):
+        assert name in self.registry_dict["embedding_model"], f"embedding_model={name} not found!"
+        return self.registry_dict["embedding_model"][name]
+
+    def resolve_llm(self, name: str):
+        assert name in self.registry_dict["llm"], f"llm={name} not found!"
+        return self.registry_dict["llm"][name]
+
+    def resolve_vector_store(self, name: str):
+        assert name in self.registry_dict["vector_store"], f"vector_store={name} not found!"
+        return self.registry_dict["vector_store"][name]
+
+    def resolve_op(self, name: str):
+        assert name in self.registry_dict["op"], f"op={name} not found!"
+        return self.registry_dict["op"][name]
+
+    def resolve_tool_flow(self, name: str):
+        assert name in self.registry_dict["tool_flow"], f"tool_flow={name} not found!"
+        return self.registry_dict["tool_flow"][name]
+
+    def resolve_service(self, name: str):
+        assert name in self.registry_dict["service"], f"service={name} not found!"
+        return self.registry_dict["service"][name]
+
+
+C = ServiceContext()

flowllm/embedding_model/__init__.py

@@ -0,0 +1 @@
+from .openai_compatible_embedding_model import OpenAICompatibleEmbeddingModel