fabricatio 0.2.5.dev5__cp312-cp312-win_amd64.whl → 0.2.6.dev1__cp312-cp312-win_amd64.whl

fabricatio/config.py

@@ -19,8 +19,6 @@ from pydantic import (
 )
 from pydantic_settings import (
     BaseSettings,
-    DotEnvSettingsSource,
-    EnvSettingsSource,
     PydanticBaseSettingsSource,
     PyprojectTomlConfigSettingsSource,
     SettingsConfigDict,
@@ -68,7 +66,7 @@ class LLMConfig(BaseModel):
     temperature: NonNegativeFloat = Field(default=1.0)
     """The temperature of the LLM model. Controls randomness in generation. Set to 1.0 as per request."""
 
-    stop_sign: str | List[str] = Field(default_factory=lambda :["\n\n\n", "User:"])
+    stop_sign: str | List[str] = Field(default_factory=lambda: ["\n\n\n", "User:"])
     """The stop sign of the LLM model. No default stop sign specified."""
 
     top_p: NonNegativeFloat = Field(default=0.35)
@@ -83,6 +81,12 @@ class LLMConfig(BaseModel):
     max_tokens: PositiveInt = Field(default=8192)
     """The maximum number of tokens to generate. Set to 8192 as per request."""
 
+    rpm: Optional[PositiveInt] = Field(default=100)
+    """The rate limit of the LLM model in requests per minute. None means not checked."""
+
+    tpm: Optional[PositiveInt] = Field(default=1000000)
+    """The rate limit of the LLM model in tokens per minute. None means not checked."""
+
 
 class EmbeddingConfig(BaseModel):
     """Embedding configuration class."""
@@ -222,6 +226,12 @@ class TemplateConfig(BaseModel):
     review_string_template: str = Field(default="review_string")
     """The name of the review string template which will be used to review a string."""
 
+    generic_string_template: str = Field(default="generic_string")
+    """The name of the generic string template which will be used to review a string."""
+
+    correct_template: str = Field(default="correct")
+    """The name of the correct template which will be used to correct a string."""
+
 
 class MagikaConfig(BaseModel):
     """Magika configuration class."""
@@ -285,6 +295,19 @@ class CacheConfig(BaseModel):
     """Whether to enable cache."""
 
 
+class RoutingConfig(BaseModel):
+    """Routing configuration class."""
+
+    model_config = ConfigDict(use_attribute_docstrings=True)
+
+    allowed_fails: Optional[int] = 1
+    """The number of allowed fails before the routing is considered failed."""
+    retry_after: int = 15
+    """The time in seconds to wait before retrying the routing after a fail."""
+    cooldown_time: Optional[int] = 120
+    """The time in seconds to wait before retrying the routing after a cooldown."""
+
+
 class Settings(BaseSettings):
     """Application settings class.
 
@@ -310,6 +333,9 @@ class Settings(BaseSettings):
     llm: LLMConfig = Field(default_factory=LLMConfig)
     """LLM Configuration"""
 
+    routing: RoutingConfig = Field(default_factory=RoutingConfig)
+    """Routing Configuration"""
+
     embedding: EmbeddingConfig = Field(default_factory=EmbeddingConfig)
     """Embedding Configuration"""
 
@@ -348,6 +374,9 @@ class Settings(BaseSettings):
     ) -> tuple[PydanticBaseSettingsSource, ...]:
         """Customize settings sources.
 
+        This method customizes the settings sources used by the application. It returns a tuple of settings sources, including
+        the dotenv settings source, environment settings source, a custom TomlConfigSettingsSource, and a custom
+
         Args:
             settings_cls (type[BaseSettings]): The settings class.
             init_settings (PydanticBaseSettingsSource): Initial settings source.
@@ -359,10 +388,12 @@ class Settings(BaseSettings):
             tuple[PydanticBaseSettingsSource, ...]: A tuple of settings sources.
         """
         return (
-            DotEnvSettingsSource(settings_cls),
-            EnvSettingsSource(settings_cls),
-            TomlConfigSettingsSource(settings_cls),
+            init_settings,
+            dotenv_settings,
+            env_settings,
+            file_secret_settings,
             PyprojectTomlConfigSettingsSource(settings_cls),
+            TomlConfigSettingsSource(settings_cls),
         )
 
 

fabricatio/fs/__init__.py

@@ -11,9 +11,10 @@ from fabricatio.fs.curd import (
     move_file,
     tree,
 )
-from fabricatio.fs.readers import magika, safe_json_read, safe_text_read
+from fabricatio.fs.readers import MAGIKA, safe_json_read, safe_text_read
 
 __all__ = [
+    "MAGIKA",
     "absolute_path",
     "copy_file",
     "create_directory",
@@ -21,7 +22,6 @@ __all__ = [
     "delete_file",
     "dump_text",
     "gather_files",
-    "magika",
     "move_file",
     "safe_json_read",
     "safe_text_read",

fabricatio/fs/readers.py

@@ -9,7 +9,7 @@ from magika import Magika
 from fabricatio.config import configs
 from fabricatio.journal import logger
 
-magika = Magika(model_dir=configs.magika.model_dir)
+MAGIKA = Magika(model_dir=configs.magika.model_dir)
 
 
 def safe_text_read(path: Path | str) -> str:

fabricatio/journal.py

@@ -19,10 +19,3 @@ logger.add(
 logger.add(sys.stderr, level=configs.debug.log_level)
 
 __all__ = ["logger"]
-if __name__ == "__main__":
-    logger.debug("This is a trace message.")
-    logger.info("This is an information message.")
-    logger.success("This is a success message.")
-    logger.warning("This is a warning message.")
-    logger.error("This is an error message.")
-    logger.critical("This is a critical message.")

fabricatio/models/action.py

@@ -3,9 +3,9 @@
 import traceback
 from abc import abstractmethod
 from asyncio import Queue, create_task
-from typing import Any, Dict, Self, Tuple, Type, Union, Unpack, final
+from typing import Any, Dict, Self, Tuple, Type, Union, final
 
-from fabricatio.capabilities.review import Review
+from fabricatio.capabilities.correct import Correct
 from fabricatio.capabilities.task import HandleTask, ProposeTask
 from fabricatio.journal import logger
 from fabricatio.models.generic import WithBriefing
@@ -14,7 +14,7 @@ from fabricatio.models.usages import ToolBoxUsage
 from pydantic import Field, PrivateAttr
 
 
-class Action(HandleTask, ProposeTask, Review):
+class Action(HandleTask, ProposeTask, Correct):
     """Class that represents an action to be executed in a workflow."""
 
     name: str = Field(default="")
@@ -37,7 +37,7 @@ class Action(HandleTask, ProposeTask, Review):
         self.description = self.description or self.__class__.__doc__ or ""
 
     @abstractmethod
-    async def _execute(self, **cxt: Unpack) -> Any:
+    async def _execute(self, **cxt) -> Any:
         """Execute the action with the provided arguments.
 
         Args:

fabricatio/models/generic.py

@@ -2,13 +2,13 @@
 
 from abc import abstractmethod
 from pathlib import Path
-from typing import Any, Callable, Dict, Iterable, List, Optional, Self, Union, final
+from typing import Any, Callable, Dict, Iterable, List, Optional, Self, Union, final, overload
 
 import orjson
 from fabricatio._rust import blake3_hash
-from fabricatio._rust_instances import template_manager
+from fabricatio._rust_instances import TEMPLATE_MANAGER
 from fabricatio.config import configs
-from fabricatio.fs.readers import magika, safe_text_read
+from fabricatio.fs.readers import MAGIKA, safe_text_read
 from fabricatio.journal import logger
 from fabricatio.parser import JsonCapture
 from pydantic import (
@@ -40,6 +40,14 @@ class Display(Base):
         """
         return self.model_dump_json(indent=1)
 
+    def compact(self) -> str:
+        """Display the model in a compact JSON string.
+
+        Returns:
+            str: The compact JSON string of the model.
+        """
+        return self.model_dump_json()
+
 
 class Named(Base):
     """Class that includes a name attribute."""
@@ -100,7 +108,15 @@ class CreateJsonObjPrompt(WithFormatedJsonSchema):
     """Class that provides a prompt for creating a JSON object."""
 
     @classmethod
-    def create_json_prompt(cls, requirement: str) -> str:
+    @overload
+    def create_json_prompt(cls, requirement: List[str]) -> List[str]: ...
+
+    @classmethod
+    @overload
+    def create_json_prompt(cls, requirement: str) -> str: ...
+
+    @classmethod
+    def create_json_prompt(cls, requirement: str | List[str]) -> str | List[str]:
         """Create the prompt for creating a JSON object with given requirement.
 
         Args:
@@ -109,10 +125,18 @@ class CreateJsonObjPrompt(WithFormatedJsonSchema):
         Returns:
             str: The prompt for creating a JSON object with given requirement.
         """
-        return template_manager.render_template(
-            configs.templates.create_json_obj_template,
-            {"requirement": requirement, "json_schema": cls.formated_json_schema()},
-        )
+        if isinstance(requirement, str):
+            return TEMPLATE_MANAGER.render_template(
+                configs.templates.create_json_obj_template,
+                {"requirement": requirement, "json_schema": cls.formated_json_schema()},
+            )
+        return [
+            TEMPLATE_MANAGER.render_template(
+                configs.templates.create_json_obj_template,
+                {"requirement": r, "json_schema": cls.formated_json_schema()},
+            )
+            for r in requirement
+        ]
 
 
 class InstantiateFromString(Base):
@@ -231,13 +255,13 @@ class WithDependency(Base):
         Returns:
             str: The generated prompt for the task.
         """
-        return template_manager.render_template(
+        return TEMPLATE_MANAGER.render_template(
             configs.templates.dependencies_template,
             {
                 (pth := Path(p)).name: {
                     "path": pth.as_posix(),
                     "exists": pth.exists(),
-                    "description": (identity := magika.identify_path(pth)).output.description,
+                    "description": (identity := MAGIKA.identify_path(pth)).output.description,
                     "size": f"{pth.stat().st_size / (1024 * 1024) if pth.exists() and pth.is_file() else 0:.3f} MB",
                     "content": (text := safe_text_read(pth)),
                     "lines": len(text.splitlines()),
@@ -307,6 +331,12 @@ class ScopedConfig(Base):
     llm_max_tokens: Optional[PositiveInt] = None
     """The maximum number of tokens to generate."""
 
+    llm_tpm: Optional[PositiveInt] = None
+    """The tokens per minute of the LLM model."""
+
+    llm_rpm: Optional[PositiveInt] = None
+    """The requests per minute of the LLM model."""
+
     embedding_api_endpoint: Optional[HttpUrl] = None
     """The OpenAI API endpoint."""
 

fabricatio/models/kwargs_types.py

@@ -12,7 +12,7 @@ class CollectionSimpleConfigKwargs(TypedDict, total=False):
     These arguments are typically used when configuring connections to vector databases.
     """
 
-    dimension: int
+    dimension: int | None
     timeout: float
 
 
@@ -23,7 +23,7 @@ class FetchKwargs(TypedDict, total=False):
     and result limiting parameters.
     """
 
-    collection_name: str
+    collection_name: str | None
     similarity_threshold: float
     result_per_query: int
 

fabricatio/models/role.py

@@ -2,7 +2,7 @@
 
 from typing import Any, Self, Set
 
-from fabricatio.capabilities.review import Review
+from fabricatio.capabilities.correct import Correct
 from fabricatio.capabilities.task import HandleTask, ProposeTask
 from fabricatio.core import env
 from fabricatio.journal import logger
@@ -12,7 +12,7 @@ from fabricatio.models.tool import ToolBox
 from pydantic import Field
 
 
-class Role(ProposeTask, HandleTask, Review):
+class Role(ProposeTask, HandleTask, Correct):
     """Class that represents a role with a registry of events and workflows."""
 
     registry: dict[Event | str, WorkFlow] = Field(default_factory=dict)

fabricatio/models/task.py

@@ -6,7 +6,7 @@ It includes methods to manage the task's lifecycle, such as starting, finishing,
 from asyncio import Queue
 from typing import Any, List, Optional, Self
 
-from fabricatio._rust_instances import template_manager
+from fabricatio._rust_instances import TEMPLATE_MANAGER
 from fabricatio.config import configs
 from fabricatio.core import env
 from fabricatio.journal import logger
@@ -253,7 +253,7 @@ class Task[T](WithBriefing, ProposedAble, WithDependency):
         Returns:
             str: The briefing of the task.
         """
-        return template_manager.render_template(
+        return TEMPLATE_MANAGER.render_template(
             configs.templates.task_briefing_template,
             self.model_dump(),
         )

fabricatio/models/usages.py

@@ -5,7 +5,7 @@ from typing import Callable, Dict, Iterable, List, Optional, Self, Sequence, Set
 
 import asyncstdlib
 import litellm
-from fabricatio._rust_instances import template_manager
+from fabricatio._rust_instances import TEMPLATE_MANAGER
 from fabricatio.config import configs
 from fabricatio.journal import logger
 from fabricatio.models.generic import ScopedConfig, WithBriefing
@@ -13,8 +13,9 @@ from fabricatio.models.kwargs_types import ChooseKwargs, EmbeddingKwargs, Genera
 from fabricatio.models.task import Task
 from fabricatio.models.tool import Tool, ToolBox
 from fabricatio.models.utils import Messages
-from fabricatio.parser import JsonCapture
-from litellm import stream_chunk_builder
+from fabricatio.parser import GenericCapture, JsonCapture
+from litellm import Router, stream_chunk_builder
+from litellm.types.router import Deployment, LiteLLM_Params, ModelInfo
 from litellm.types.utils import (
     Choices,
     EmbeddingResponse,
@@ -22,7 +23,7 @@ from litellm.types.utils import (
     StreamingChoices,
     TextChoices,
 )
-from litellm.utils import CustomStreamWrapper
+from litellm.utils import CustomStreamWrapper  # pyright: ignore [reportPrivateImportUsage]
 from more_itertools import duplicates_everseen
 from pydantic import Field, NonNegativeInt, PositiveInt
 
@@ -30,20 +31,33 @@ if configs.cache.enabled and configs.cache.type:
     litellm.enable_cache(type=configs.cache.type, **configs.cache.params)
     logger.success(f"{configs.cache.type.name} Cache enabled")
 
+ROUTER = Router(
+    routing_strategy="usage-based-routing-v2",
+    allowed_fails=configs.routing.allowed_fails,
+    retry_after=configs.routing.retry_after,
+    cooldown_time=configs.routing.cooldown_time,
+)
+
 
 class LLMUsage(ScopedConfig):
     """Class that manages LLM (Large Language Model) usage parameters and methods."""
 
+    def _deploy(self, deployment: Deployment) -> Router:
+        """Add a deployment to the router."""
+        self._added_deployment = ROUTER.upsert_deployment(deployment)
+        return ROUTER
+
     @classmethod
     def _scoped_model(cls) -> Type["LLMUsage"]:
         return LLMUsage
 
+    # noinspection PyTypeChecker,PydanticTypeChecker
     async def aquery(
         self,
         messages: List[Dict[str, str]],
         n: PositiveInt | None = None,
         **kwargs: Unpack[LLMKwargs],
-    ) -> ModelResponse:
+    ) -> ModelResponse | CustomStreamWrapper:
         """Asynchronously queries the language model to generate a response based on the provided messages and parameters.
 
         Args:
@@ -55,19 +69,33 @@ class LLMUsage(ScopedConfig):
             ModelResponse | CustomStreamWrapper: An object containing the generated response and other metadata from the model.
         """
         # Call the underlying asynchronous completion function with the provided and default parameters
-        return await litellm.acompletion(
+        # noinspection PyTypeChecker,PydanticTypeChecker
+
+        return await self._deploy(
+            Deployment(
+                model_name=(m_name := kwargs.get("model") or self.llm_model or configs.llm.model),
+                litellm_params=(
+                    p := LiteLLM_Params(
+                        api_key=(self.llm_api_key or configs.llm.api_key).get_secret_value(),
+                        api_base=(self.llm_api_endpoint or configs.llm.api_endpoint).unicode_string(),
+                        model=m_name,
+                        tpm=self.llm_tpm or configs.llm.tpm,
+                        rpm=self.llm_rpm or configs.llm.rpm,
+                        max_retries=kwargs.get("max_retries") or self.llm_max_retries or configs.llm.max_retries,
+                        timeout=kwargs.get("timeout") or self.llm_timeout or configs.llm.timeout,
+                    )
+                ),
+                model_info=ModelInfo(id=hash(m_name + p.model_dump_json(exclude_none=True))),
+            )
+        ).acompletion(
             messages=messages,
             n=n or self.llm_generation_count or configs.llm.generation_count,
-            model=kwargs.get("model") or self.llm_model or configs.llm.model,
+            model=m_name,
             temperature=kwargs.get("temperature") or self.llm_temperature or configs.llm.temperature,
             stop=kwargs.get("stop") or self.llm_stop_sign or configs.llm.stop_sign,
             top_p=kwargs.get("top_p") or self.llm_top_p or configs.llm.top_p,
             max_tokens=kwargs.get("max_tokens") or self.llm_max_tokens or configs.llm.max_tokens,
             stream=kwargs.get("stream") or self.llm_stream or configs.llm.stream,
-            timeout=kwargs.get("timeout") or self.llm_timeout or configs.llm.timeout,
-            max_retries=kwargs.get("max_retries") or self.llm_max_retries or configs.llm.max_retries,
-            api_key=(self.llm_api_key or configs.llm.api_key).get_secret_value(),
-            base_url=(self.llm_api_endpoint or configs.llm.api_endpoint).unicode_string(),
             cache={
                 "no-cache": kwargs.get("no_cache"),
                 "no-store": kwargs.get("no_store"),
@@ -192,31 +220,31 @@ class LLMUsage(ScopedConfig):
     @overload
     async def aask_validate[T](
         self,
-        question: str,
+        question: List[str],
         validator: Callable[[str], T | None],
-        default: None = None,
+        default: T,
         max_validations: PositiveInt = 2,
         **kwargs: Unpack[GenerateKwargs],
-    ) -> Optional[T]: ...
-
+    ) -> List[T]: ...
     @overload
     async def aask_validate[T](
         self,
-        question: List[str],
+        question: str,
         validator: Callable[[str], T | None],
         default: None = None,
         max_validations: PositiveInt = 2,
         **kwargs: Unpack[GenerateKwargs],
-    ) -> List[Optional[T]]: ...
+    ) -> Optional[T]: ...
+
     @overload
     async def aask_validate[T](
         self,
         question: List[str],
         validator: Callable[[str], T | None],
-        default: T,
+        default: None = None,
         max_validations: PositiveInt = 2,
         **kwargs: Unpack[GenerateKwargs],
-    ) -> List[T]: ...
+    ) -> List[Optional[T]]: ...
 
     async def aask_validate[T](
         self,
@@ -274,7 +302,7 @@ class LLMUsage(ScopedConfig):
             List[str]: The validated response as a list of strings.
         """
         return await self.aask_validate(
-            template_manager.render_template(
+            TEMPLATE_MANAGER.render_template(
                 configs.templates.liststr_template,
                 {"requirement": requirement, "k": k},
             ),
@@ -293,7 +321,7 @@ class LLMUsage(ScopedConfig):
             List[str]: The validated response as a list of strings.
         """
         return await self.aliststr(
-            template_manager.render_template(
+            TEMPLATE_MANAGER.render_template(
                 configs.templates.pathstr_template,
                 {"requirement": requirement},
             ),
@@ -318,6 +346,25 @@ class LLMUsage(ScopedConfig):
             )
         ).pop()
 
+    async def ageneric_string(self, requirement: str, **kwargs: Unpack[ValidateKwargs[str]]) -> str:
+        """Asynchronously generates a generic string based on a given requirement.
+
+        Args:
+            requirement (str): The requirement for the string.
+            **kwargs (Unpack[GenerateKwargs]): Additional keyword arguments for the LLM usage.
+
+        Returns:
+            str: The generated string.
+        """
+        return await self.aask_validate(
+            TEMPLATE_MANAGER.render_template(
+                configs.templates.generic_string_template,
+                {"requirement": requirement, "language": GenericCapture.capture_type},
+            ),
+            validator=lambda resp: GenericCapture.capture(resp),
+            **kwargs,
+        )
+
     async def achoose[T: WithBriefing](
         self,
         instruction: str,
@@ -344,7 +391,7 @@ class LLMUsage(ScopedConfig):
         if dup := duplicates_everseen(choices, key=lambda x: x.name):
             logger.error(err := f"Redundant choices: {dup}")
             raise ValueError(err)
-        prompt = template_manager.render_template(
+        prompt = TEMPLATE_MANAGER.render_template(
             configs.templates.make_choice_template,
             {
                 "instruction": instruction,
@@ -417,7 +464,7 @@ class LLMUsage(ScopedConfig):
             bool: The judgment result (True or False) based on the AI's response.
         """
         return await self.aask_validate(
-            question=template_manager.render_template(
+            question=TEMPLATE_MANAGER.render_template(
                 configs.templates.make_judgment_template,
                 {"prompt": prompt, "affirm_case": affirm_case, "deny_case": deny_case},
             ),

fabricatio/models/utils.py

@@ -4,6 +4,7 @@ from enum import Enum
 from typing import Any, Dict, List, Literal, Optional, Self
 
 from pydantic import BaseModel, ConfigDict, Field
+from questionary import text
 
 
 class Message(BaseModel):
@@ -144,3 +145,23 @@ class TaskStatus(Enum):
     Finished = "finished"
     Failed = "failed"
     Cancelled = "cancelled"
+
+
+async def ask_edit(
+    text_seq: List[str],
+) -> List[str]:
+    """Asks the user to edit a list of texts.
+
+    Args:
+        text_seq (List[str]): A list of texts to be edited.
+
+    Returns:
+        List[str]: A list of edited texts.
+        If the user does not edit a text, it will not be included in the returned list.
+    """
+    res = []
+    for i, t in enumerate(text_seq):
+        edited = await text(f"[{i}] ", default=t).ask_async()
+        if edited:
+            res.append(edited)
+    return res

fabricatio/parser.py

@@ -35,7 +35,7 @@ class Capture(BaseModel):
         """Initialize the compiled pattern."""
         self._compiled = compile(self.pattern, self.flags)
 
-    def fix[T](self, text: str | Iterable[str]|T) -> str | List[str]|T:
+    def fix[T](self, text: str | Iterable[str] | T) -> str | List[str] | T:
         """Fix the text using the pattern.
 
         Args:
@@ -47,8 +47,8 @@ class Capture(BaseModel):
         match self.capture_type:
             case "json":
                 if isinstance(text, str):
-                    return repair_json(text,ensure_ascii=False)
-                return [repair_json(item) for item in text]
+                    return repair_json(text, ensure_ascii=False)
+                return [repair_json(item, ensure_ascii=False) for item in text]
             case _:
                 return text
 
@@ -134,8 +134,16 @@ class Capture(BaseModel):
         """
         return cls(pattern=f"```{language}\n(.*?)\n```", capture_type=language)
 
+    @classmethod
+    def capture_generic_block(cls, language: str) -> Self:
+        """Capture the first occurrence of a generic code block in the given text.
+
+        Returns:
+            Self: The instance of the class with the captured code block.
+        """
+        return cls(pattern=f"--- Start of {language} ---\n(.*?)\n--- end of {language} ---", capture_type=language)
+
 
 JsonCapture = Capture.capture_code_block("json")
 PythonCapture = Capture.capture_code_block("python")
-MarkdownCapture = Capture.capture_code_block("markdown")
-CodeBlockCapture = Capture(pattern="```.*?\n(.*?)\n```")
+GenericCapture = Capture.capture_generic_block("String")

{fabricatio-0.2.5.dev5.dist-info → fabricatio-0.2.6.dev1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fabricatio
-Version: 0.2.5.dev5
+Version: 0.2.6.dev1
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: 3.12
@@ -176,7 +176,7 @@ if __name__ == "__main__":
 ### Template Management and Rendering
 
 ```python
-from fabricatio._rust_instances import template_manager
+from fabricatio._rust_instances import TEMPLATE_MANAGER
 
 template_name = "claude-xml.hbs"
 data = {
@@ -185,7 +185,7 @@ data = {
     "files": [{"path": "file1.py", "code": "print('Hello')"}],
 }
 
-rendered_template = template_manager.render_template(template_name, data)
+rendered_template = TEMPLATE_MANAGER.render_template(template_name, data)
 print(rendered_template)
 ```