fabricatio 0.2.3.dev2__cp312-cp312-win_amd64.whl → 0.2.4__cp312-cp312-win_amd64.whl

fabricatio/capabilities/rating.py

@@ -131,8 +131,7 @@ class GiveRating(WithBriefing, LLMUsage):
 
         def _validator(response: str) -> Dict[str, str] | None:
             if (
-                (json_data := JsonCapture.convert_with(response, orjson.loads)) is not None
-                and isinstance(json_data, dict)
+                (json_data := JsonCapture.validate_with(response, target_type=dict, elements_type=str)) is not None
                 and json_data.keys() == criteria
                 and all(isinstance(v, str) for v in json_data.values())
             ):
@@ -173,11 +172,10 @@ class GiveRating(WithBriefing, LLMUsage):
 
         def _validator(response: str) -> Set[str] | None:
             if (
-                (json_data := JsonCapture.convert_with(response, orjson.loads)) is not None
-                and isinstance(json_data, list)
-                and all(isinstance(v, str) for v in json_data)
-                and (criteria_count == 0 or len(json_data) == criteria_count)
-            ):
+                json_data := JsonCapture.validate_with(
+                    response, target_type=list, elements_type=str, length=criteria_count
+                )
+            ) is not None:
                 return set(json_data)
             return None
 
@@ -219,27 +217,6 @@ class GiveRating(WithBriefing, LLMUsage):
         Returns:
             Set[str]: A set of drafted rating criteria.
         """
-
-        def _reasons_validator(response: str) -> List[str] | None:
-            if (
-                (json_data := JsonCapture.convert_with(response, orjson.loads)) is not None
-                and isinstance(json_data, list)
-                and all(isinstance(v, str) for v in json_data)
-                and len(json_data) == reasons_count
-            ):
-                return json_data
-            return None
-
-        def _criteria_validator(response: str) -> Set[str] | None:
-            if (
-                (json_data := JsonCapture.convert_with(response, orjson.loads)) is not None
-                and isinstance(json_data, list)
-                and all(isinstance(v, str) for v in json_data)
-                and len(json_data) == criteria_count
-            ):
-                return set(json_data)
-            return None
-
         kwargs = GenerateKwargs(system_message=f"# your personal briefing: \n{self.briefing}", **kwargs)
         # extract reasons from the comparison of ordered pairs of extracted from examples
         reasons = flatten(
@@ -256,7 +233,9 @@ class GiveRating(WithBriefing, LLMUsage):
                     )
                     for pair in (permutations(examples, 2))
                 ],
-                validator=_reasons_validator,
+                validator=lambda resp: JsonCapture.validate_with(
+                    resp, target_type=list, elements_type=str, length=reasons_count
+                ),
                 **kwargs,
             )
         )
@@ -272,7 +251,9 @@ class GiveRating(WithBriefing, LLMUsage):
                     },
                 )
             ),
-            validator=_criteria_validator,
+            validator=lambda resp: set(out)
+            if (out := JsonCapture.validate_with(resp, target_type=list, elements_type=str, length=criteria_count))
+            else None,
             **kwargs,
         )
 
@@ -295,11 +276,6 @@ class GiveRating(WithBriefing, LLMUsage):
         if len(criteria) < 2:  # noqa: PLR2004
             raise ValueError("At least two criteria are required to draft rating weights")
 
-        def _validator(resp: str) -> float | None:
-            if (cap := JsonCapture.convert_with(resp, orjson.loads)) is not None and isinstance(cap, float):
-                return cap
-            return None
-
         criteria = list(criteria)  # freeze the order
         windows = windowed(criteria, 2)
 
@@ -316,7 +292,7 @@ class GiveRating(WithBriefing, LLMUsage):
                 )
                 for pair in windows
             ],
-            validator=_validator,
+            validator=lambda resp: JsonCapture.validate_with(resp, target_type=float),
             **GenerateKwargs(system_message=f"# your personal briefing: \n{self.briefing}", **kwargs),
         )
         weights = [1]

fabricatio/capabilities/task.py

@@ -5,21 +5,21 @@ from typing import Any, Dict, List, Optional, Tuple, Unpack
 
 import orjson
 from fabricatio._rust_instances import template_manager
+from fabricatio.capabilities.propose import Propose
 from fabricatio.config import configs
 from fabricatio.models.generic import WithBriefing
 from fabricatio.models.kwargs_types import ChooseKwargs, ValidateKwargs
 from fabricatio.models.task import Task
 from fabricatio.models.tool import Tool, ToolExecutor
-from fabricatio.models.usages import LLMUsage, ToolBoxUsage
+from fabricatio.models.usages import ToolBoxUsage
 from fabricatio.parser import JsonCapture, PythonCapture
 from loguru import logger
-from pydantic import ValidationError
 
 
-class ProposeTask(WithBriefing, LLMUsage):
+class ProposeTask(WithBriefing, Propose):
     """A class that proposes a task based on a prompt."""
 
-    async def propose[T](
+    async def propose_task[T](
         self,
         prompt: str,
         **kwargs: Unpack[ValidateKwargs],
@@ -34,27 +34,10 @@ class ProposeTask(WithBriefing, LLMUsage):
             A Task object based on the proposal result.
         """
         if not prompt:
-            err = f"{self.name}: Prompt must be provided."
-            logger.error(err)
+            logger.error(err := f"{self.name}: Prompt must be provided.")
             raise ValueError(err)
 
-        def _validate_json(response: str) -> None | Task:
-            try:
-                cap = JsonCapture.capture(response)
-                logger.debug(f"Response: \n{response}")
-                logger.info(f"Captured JSON: \n{cap}")
-                return Task.model_validate_json(cap)
-            except ValidationError as e:
-                logger.error(f"Failed to parse task from JSON: {e}")
-                return None
-
-        template_data = {"prompt": prompt, "json_example": Task.json_example()}
-        return await self.aask_validate(
-            question=template_manager.render_template(configs.templates.propose_task_template, template_data),
-            validator=_validate_json,
-            system_message=f"# your personal briefing: \n{self.briefing}",
-            **kwargs,
-        )
+        return await self.propose(Task, prompt, system_message=f"# your personal briefing: \n{self.briefing}", **kwargs)
 
 
 class HandleTask(WithBriefing, ToolBoxUsage):

fabricatio/config.py

@@ -80,6 +80,33 @@ class LLMConfig(BaseModel):
     """The maximum number of tokens to generate. Set to 8192 as per request."""
 
 
+class EmbeddingConfig(BaseModel):
+    """Embedding configuration class."""
+
+    model_config = ConfigDict(use_attribute_docstrings=True)
+
+    model: str = Field(default="text-embedding-ada-002")
+    """The embedding model name. """
+
+    dimensions: Optional[PositiveInt] = Field(default=None)
+    """The dimensions of the embedding. None means not checked."""
+
+    timeout: Optional[PositiveInt] = Field(default=None)
+    """The timeout of the embedding model in seconds."""
+
+    max_sequence_length: PositiveInt = Field(default=8192)
+    """The maximum sequence length of the embedding model. Default is 8192 as per request."""
+
+    caching: bool = Field(default=False)
+    """Whether to cache the embedding. Default is False."""
+
+    api_endpoint: Optional[HttpUrl] = None
+    """The OpenAI API endpoint."""
+
+    api_key: Optional[SecretStr] = None
+    """The OpenAI API key."""
+
+
 class PymitterConfig(BaseModel):
     """Pymitter configuration class.
 
@@ -140,8 +167,8 @@ class TemplateConfig(BaseModel):
     template_suffix: str = Field(default="hbs", frozen=True)
     """The suffix of the templates."""
 
-    propose_task_template: str = Field(default="propose_task")
-    """The name of the propose task template which will be used to propose a task."""
+    create_json_obj_template: str = Field(default="create_json_obj")
+    """The name of the create json object template which will be used to create a json object."""
 
     draft_tool_usage_code_template: str = Field(default="draft_tool_usage_code")
     """The name of the draft tool usage code template which will be used to draft tool usage code."""
@@ -176,6 +203,18 @@ class TemplateConfig(BaseModel):
     draft_rating_weights_klee_template: str = Field(default="draft_rating_weights_klee")
     """The name of the draft rating weights klee template which will be used to draft rating weights with Klee method."""
 
+    retrieved_display_template: str = Field(default="retrieved_display")
+    """The name of the retrieved display template which will be used to display retrieved documents."""
+
+    liststr_template: str = Field(default="liststr")
+    """The name of the liststr template which will be used to display a list of strings."""
+
+    refined_query_template: str = Field(default="refined_query")
+    """The name of the refined query template which will be used to refine a query."""
+
+    pathstr_template: str = Field(default="pathstr")
+    """The name of the pathstr template which will be used to acquire a path of strings."""
+
 
 class MagikaConfig(BaseModel):
     """Magika configuration class."""
@@ -219,6 +258,8 @@ class RagConfig(BaseModel):
     """The timeout of the Milvus server."""
     milvus_token: Optional[SecretStr] = Field(default=None)
     """The token of the Milvus server."""
+    milvus_dimensions: Optional[PositiveInt] = Field(default=None)
+    """The dimensions of the Milvus server."""
 
 
 class Settings(BaseSettings):
@@ -246,6 +287,9 @@ class Settings(BaseSettings):
     llm: LLMConfig = Field(default_factory=LLMConfig)
     """LLM Configuration"""
 
+    embedding: EmbeddingConfig = Field(default_factory=EmbeddingConfig)
+    """Embedding Configuration"""
+
     debug: DebugConfig = Field(default_factory=DebugConfig)
     """Debug Configuration"""
 

fabricatio/fs/__init__.py

@@ -1,5 +1,27 @@
 """FileSystem manipulation module for Fabricatio."""
 
-from fabricatio.fs.readers import magika
+from fabricatio.fs.curd import (
+    absolute_path,
+    copy_file,
+    create_directory,
+    delete_directory,
+    delete_file,
+    dump_text,
+    move_file,
+    tree,
+)
+from fabricatio.fs.readers import magika, safe_json_read, safe_text_read
 
-__all__ = ["magika"]
+__all__ = [
+    "absolute_path",
+    "copy_file",
+    "create_directory",
+    "delete_directory",
+    "delete_file",
+    "dump_text",
+    "magika",
+    "move_file",
+    "safe_json_read",
+    "safe_text_read",
+    "tree",
+]

fabricatio/fs/curd.py

@@ -2,14 +2,14 @@
 
 import shutil
 import subprocess
+from os import PathLike
 from pathlib import Path
 from typing import Union
 
-from fabricatio.decorators import depend_on_external_cmd, logging_execution_info
+from fabricatio.decorators import depend_on_external_cmd
 from fabricatio.journal import logger
 
 
-@logging_execution_info
 def dump_text(path: Union[str, Path], text: str) -> None:
     """Dump text to a file. you need to make sure the file's parent directory exists.
 
@@ -23,7 +23,6 @@ def dump_text(path: Union[str, Path], text: str) -> None:
     Path(path).write_text(text, encoding="utf-8", errors="ignore")
 
 
-@logging_execution_info
 def copy_file(src: Union[str, Path], dst: Union[str, Path]) -> None:
     """Copy a file from source to destination.
 
@@ -43,7 +42,6 @@ def copy_file(src: Union[str, Path], dst: Union[str, Path]) -> None:
         raise
 
 
-@logging_execution_info
 def move_file(src: Union[str, Path], dst: Union[str, Path]) -> None:
     """Move a file from source to destination.
 
@@ -63,7 +61,6 @@ def move_file(src: Union[str, Path], dst: Union[str, Path]) -> None:
         raise
 
 
-@logging_execution_info
 def delete_file(file_path: Union[str, Path]) -> None:
     """Delete a file.
 
@@ -82,7 +79,6 @@ def delete_file(file_path: Union[str, Path]) -> None:
         raise
 
 
-@logging_execution_info
 def create_directory(dir_path: Union[str, Path], parents: bool = True, exist_ok: bool = True) -> None:
     """Create a directory.
 
@@ -99,7 +95,6 @@ def create_directory(dir_path: Union[str, Path], parents: bool = True, exist_ok:
         raise
 
 
-@logging_execution_info
 @depend_on_external_cmd(
     "erd",
     "Please install `erd` using `cargo install erdtree` or `scoop install erdtree`.",
@@ -111,7 +106,6 @@ def tree(dir_path: Union[str, Path]) -> str:
     return subprocess.check_output(("erd", dir_path.as_posix()), encoding="utf-8")  # noqa: S603
 
 
-@logging_execution_info
 def delete_directory(dir_path: Union[str, Path]) -> None:
     """Delete a directory and its contents.
 
@@ -128,3 +122,15 @@ def delete_directory(dir_path: Union[str, Path]) -> None:
     except OSError as e:
         logger.error(f"Failed to delete directory {dir_path}: {e!s}")
         raise
+
+
+def absolute_path(path: str | Path | PathLike) -> str:
+    """Get the absolute path of a file or directory.
+
+    Args:
+        path (str, Path, PathLike): The path to the file or directory.
+
+    Returns:
+        str: The absolute path of the file or directory.
+    """
+    return Path(path).expanduser().resolve().as_posix()

fabricatio/fs/readers.py

@@ -7,6 +7,7 @@ from magika import Magika
 from orjson import orjson
 
 from fabricatio.config import configs
+from fabricatio.journal import logger
 
 magika = Magika(model_dir=configs.magika.model_dir)
 
@@ -23,7 +24,8 @@ def safe_text_read(path: Path | str) -> str:
     path = Path(path)
     try:
         return path.read_text(encoding="utf-8")
-    except (UnicodeDecodeError, IsADirectoryError, FileNotFoundError):
+    except (UnicodeDecodeError, IsADirectoryError, FileNotFoundError) as e:
+        logger.error(f"Failed to read file {path}: {e!s}")
         return ""
 
 
@@ -39,5 +41,6 @@ def safe_json_read(path: Path | str) -> Dict:
     path = Path(path)
     try:
         return orjson.loads(path.read_text(encoding="utf-8"))
-    except (orjson.JSONDecodeError, IsADirectoryError, FileNotFoundError):
+    except (orjson.JSONDecodeError, IsADirectoryError, FileNotFoundError) as e:
+        logger.error(f"Failed to read file {path}: {e!s}")
         return {}

fabricatio/models/action.py

@@ -3,7 +3,7 @@
 import traceback
 from abc import abstractmethod
 from asyncio import Queue, create_task
-from typing import Any, Dict, Self, Tuple, Type, Union, Unpack
+from typing import Any, Dict, Self, Tuple, Type, Union, Unpack, final
 
 from fabricatio.capabilities.rating import GiveRating
 from fabricatio.capabilities.task import HandleTask, ProposeTask
@@ -17,11 +17,25 @@ from pydantic import Field, PrivateAttr
 class Action(HandleTask, ProposeTask, GiveRating):
     """Class that represents an action to be executed in a workflow."""
 
+    name: str = Field(default="")
+    """The name of the action."""
+    description: str = Field(default="")
+    """The description of the action."""
     personality: str = Field(default="")
     """The personality of whom the action belongs to."""
     output_key: str = Field(default="")
     """The key of the output data."""
 
+    @final
+    def model_post_init(self, __context: Any) -> None:
+        """Initialize the action by setting the name if not provided.
+
+        Args:
+            __context: The context to be used for initialization.
+        """
+        self.name = self.name or self.__class__.__name__
+        self.description = self.description or self.__class__.__doc__ or ""
+
     @abstractmethod
     async def _execute(self, **cxt: Unpack) -> Any:
         """Execute the action with the provided arguments.
@@ -34,6 +48,7 @@ class Action(HandleTask, ProposeTask, GiveRating):
         """
         pass
 
+    @final
     async def act(self, cxt: Dict[str, Any]) -> Dict[str, Any]:
         """Perform the action by executing it and setting the output data.
 
@@ -46,6 +61,7 @@ class Action(HandleTask, ProposeTask, GiveRating):
             cxt[self.output_key] = ret
         return cxt
 
+    @property
     def briefing(self) -> str:
         """Return a brief description of the action."""
         if self.personality:
@@ -91,9 +107,8 @@ class WorkFlow(WithBriefing, ToolBoxUsage):
         Returns:
             Self: The instance of the workflow with the injected personality.
         """
-        for a in self._instances:
-            if not a.personality:
-                a.personality = personality
+        for a in filter(lambda action: not action.personality, self._instances):
+            a.personality = personality
         return self
 
     async def serve(self, task: Task) -> None:

fabricatio/models/events.py

@@ -3,6 +3,7 @@
 from typing import List, Self, Union
 
 from fabricatio.config import configs
+from fabricatio.models.utils import TaskStatus
 from pydantic import BaseModel, ConfigDict, Field
 
 type EventLike = Union[str, List[str], "Event"]
@@ -33,6 +34,21 @@ class Event(BaseModel):
 
         return cls(segments=event)
 
+    @classmethod
+    def quick_instantiate(cls, event: EventLike) -> Self:
+        """Create an Event instance from a string or list of strings or an Event instance and push a wildcard and pending segment.
+
+        Args:
+            event (EventLike): The event to instantiate from.
+
+        Returns:
+            Event: The Event instance.
+
+        Notes:
+            This method is used to create an Event instance from a string or list of strings or an Event instance and push a wildcard and pending segment.
+        """
+        return cls.instantiate_from(event).push_wildcard().push_pending()
+
     def derive(self, event: EventLike) -> Self:
         """Derive a new event from this event and another event or a string."""
         return self.clone().concat(event)
@@ -59,6 +75,26 @@ class Event(BaseModel):
         """Push a wildcard segment to the event."""
         return self.push("*")
 
+    def push_pending(self) -> Self:
+        """Push a pending segment to the event."""
+        return self.push(TaskStatus.Pending.value)
+
+    def push_running(self) -> Self:
+        """Push a running segment to the event."""
+        return self.push(TaskStatus.Running.value)
+
+    def push_finished(self) -> Self:
+        """Push a finished segment to the event."""
+        return self.push(TaskStatus.Finished.value)
+
+    def push_failed(self) -> Self:
+        """Push a failed segment to the event."""
+        return self.push(TaskStatus.Failed.value)
+
+    def push_cancelled(self) -> Self:
+        """Push a cancelled segment to the event."""
+        return self.push(TaskStatus.Cancelled.value)
+
     def pop(self) -> str:
         """Pop a segment from the event."""
         return self.segments.pop()

fabricatio/models/extra.py

@@ -0,0 +1,168 @@
+"""Extra models for built-in actions."""
+
+from typing import List
+
+from fabricatio.models.generic import Base, Display, FinalizedDumpAble, PrepareVectorization, ProposedAble
+from pydantic import Field
+
+
+class Equation(Base):
+    """Structured representation of mathematical equations (including their physical or conceptual meanings)."""
+
+    description: str = Field(...)
+    """A concise explanation of the equation's meaning, purpose, and relevance in the context of the research."""
+
+    latex_code: str = Field(...)
+    """The LaTeX code used to represent the equation in a publication-ready format."""
+
+
+class Figure(Base):
+    """Structured representation of figures (including their academic significance and explanatory captions)."""
+
+    description: str = Field(...)
+    """A detailed explanation of the figure's content and its role in conveying key insights."""
+
+    figure_caption: str = Field(...)
+    """The caption accompanying the figure, summarizing its main points and academic value."""
+
+    figure_path: str = Field(...)
+    """The file path to the figure"""
+
+
+class Highlightings(Base):
+    """Structured representation of highlighted elements in an academic paper (including equations, algorithms, figures, and tables)."""
+
+    # Academic Achievements Showcase
+    highlighted_equations: List[Equation] = Field(default_factory=list)
+    """Core mathematical equations that represent breakthroughs in the field, accompanied by explanations of their physical or conceptual significance."""
+
+    highlighted_algorithms: List[str] = Field(default_factory=list)
+    """Pseudocode for key algorithms, annotated to highlight innovative components."""
+
+    highlighted_figures: List[Figure] = Field(default_factory=list)
+    """Critical diagrams or illustrations, each accompanied by a caption explaining their academic importance."""
+
+    highlighted_tables: List[str] = Field(default_factory=list)
+    """Important data tables, annotated to indicate statistical significance or other notable findings."""
+
+
+class ArticleEssence(ProposedAble, Display, PrepareVectorization):
+    """Structured representation of the core elements of an academic paper(providing a comprehensive digital profile of the paper's essential information)."""
+
+    # Basic Metadata
+    title: str = Field(...)
+    """The full title of the paper, including any subtitles if applicable."""
+
+    authors: List[str] = Field(default_factory=list)
+    """A list of the paper's authors, typically in the order of contribution."""
+
+    keywords: List[str] = Field(default_factory=list)
+    """A list of keywords that summarize the paper's focus and facilitate indexing."""
+
+    publication_year: int = Field(None)
+    """The year in which the paper was published."""
+
+    # Core Content Elements
+    domain: List[str] = Field(default_factory=list)
+    """The research domains or fields addressed by the paper (e.g., ['Natural Language Processing', 'Computer Vision'])."""
+
+    abstract: str = Field(...)
+    """A structured abstract that outlines the research problem, methodology, and conclusions in three distinct sections."""
+
+    core_contributions: List[str] = Field(default_factory=list)
+    """Key academic contributions that distinguish the paper from prior work in the field."""
+
+    technical_novelty: List[str] = Field(default_factory=list)
+    """Specific technical innovations introduced by the research, listed as individual points."""
+
+    # Academic Discussion Dimensions
+    research_problem: str = Field("")
+    """A clearly defined research question or problem addressed by the study."""
+
+    limitations: List[str] = Field(default_factory=list)
+    """An analysis of the methodological or experimental limitations of the research."""
+
+    future_work: List[str] = Field(default_factory=list)
+    """Suggestions for potential directions or topics for follow-up studies."""
+
+    impact_analysis: str = Field("")
+    """An assessment of the paper's potential influence on the development of the field."""
+
+    def _prepare_vectorization_inner(self) -> str:
+        return self.model_dump_json()
+
+
+class ArticleProposal(ProposedAble, Display):
+    """Structured representation of the proposal for an academic paper."""
+
+    title: str = Field(...)
+    """The proposed title of the paper."""
+
+    focused_problem: List[str] = Field(default_factory=list)
+    """The specific research problem or question that the paper aims to address."""
+    research_aim: List[str] = Field(default_factory=list)
+    """The main objective or goal of the research, outlining what the study aims to achieve."""
+    research_methods: List[str] = Field(default_factory=list)
+    """The methods used in the research, including the approach, techniques, and tools employed."""
+
+
+class ArticleSubsectionOutline(Base):
+    """Structured representation of the subsections of an academic paper."""
+
+    title: str = Field(...)
+    """The title of the subsection."""
+
+    description: str = Field(...)
+    """A brief description of the subsection's content should be, how it fits into the overall structure of the paper, and its significance in the context of the research."""
+
+
+class ArticleSectionOutline(Base):
+    """Structured representation of the sections of an academic paper."""
+
+    title: str = Field(...)
+    """The title of the section."""
+    description: str = Field(...)
+    """A brief description of the section's content should be, how it fits into the overall structure of the paper, and its significance in the context of the research."""
+    subsections: List[ArticleSubsectionOutline] = Field(default_factory=list)
+    """The subsections of the section, outlining their content and significance."""
+
+
+class ArticleChapterOutline(Base):
+    """Structured representation of the chapters of an academic paper."""
+
+    title: str = Field(...)
+    """The title of the chapter."""
+    description: str = Field(...)
+    """A brief description of the chapter's content should be, how it fits into the overall structure of the paper, and its significance in the context of the research."""
+    sections: List[ArticleSectionOutline] = Field(default_factory=list)
+    """The sections of the chapter, outlining their content and significance."""
+
+
+class ArticleOutline(ProposedAble, Display, FinalizedDumpAble):
+    """Structured representation of the outline for an academic paper."""
+
+    title: str = Field(...)
+    """The proposed title of the paper."""
+
+    prospect: str = Field(...)
+    """A brief description of the research problem or question that the paper aims to address manipulating methods or techniques"""
+
+    chapters: List[ArticleChapterOutline] = Field(default_factory=list)
+    """The chapters of the paper, outlining their content and significance."""
+
+    def finalized_dump(self) -> str:
+        """Finalized dump of the article outline.
+
+        Returns:
+            str: The finalized dump of the article outline.
+        """
+        lines: List[str] = []
+
+        for chapter in self.chapters:
+            lines.append(f"= {chapter.title}")
+            for section in chapter.sections:
+                lines.append(f"== {section.title}")
+                for subsection in section.subsections:
+                    lines.append(f"=== {subsection.title}")
+
+        return "\n\n".join(lines)