fabricatio 0.2.4.dev3__cp312-cp312-win_amd64.whl → 0.2.5__cp312-cp312-win_amd64.whl

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,28 @@ 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()
+
+
+def gather_files(directory: str | Path | PathLike, extension: str) -> list[str]:
+    """Gather all files with a specific extension in a directory.
+
+    Args:
+        directory (str, Path, PathLike): The directory to search in.
+        extension (str): The file extension to look for.
+
+    Returns:
+        list[str]: A list of file paths with the specified extension.
+    """
+    return [file.as_posix() for file in Path(directory).rglob(f"*.{extension}")]

fabricatio/fs/readers.py

@@ -3,10 +3,11 @@
 from pathlib import Path
 from typing import Dict
 
+import orjson
 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/journal.py

@@ -18,7 +18,7 @@ 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.")

fabricatio/models/action.py

@@ -5,7 +5,7 @@ from abc import abstractmethod
 from asyncio import Queue, create_task
 from typing import Any, Dict, Self, Tuple, Type, Union, Unpack, final
 
-from fabricatio.capabilities.rating import GiveRating
+from fabricatio.capabilities.review import Review
 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, GiveRating):
+class Action(HandleTask, ProposeTask, Review):
     """Class that represents an action to be executed in a workflow."""
 
     name: str = Field(default="")
@@ -34,7 +34,6 @@ class Action(HandleTask, ProposeTask, GiveRating):
             __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
@@ -76,7 +75,7 @@ class WorkFlow(WithBriefing, ToolBoxUsage):
     _context: Queue[Dict[str, Any]] = PrivateAttr(default_factory=lambda: Queue(maxsize=1))
     """ The context dictionary to be used for workflow execution."""
 
-    _instances: Tuple[Action, ...] = PrivateAttr(...)
+    _instances: Tuple[Action, ...] = PrivateAttr(default_factory=tuple)
     """ The instances of the workflow steps."""
 
     steps: Tuple[Union[Type[Action], Action], ...] = Field(...)
@@ -123,17 +122,16 @@ class WorkFlow(WithBriefing, ToolBoxUsage):
         current_action = None
         try:
             for step in self._instances:
-                logger.debug(f"Executing step: {step.name}")
+                logger.debug(f"Executing step: {(current_action := step.name)}")
                 act_task = create_task(step.act(await self._context.get()))
                 if task.is_cancelled():
                     act_task.cancel(f"Cancelled by task: {task.name}")
                     break
                 modified_ctx = await act_task
                 await self._context.put(modified_ctx)
-                current_action = step.name
             logger.info(f"Finished executing workflow: {self.name}")
-            final_ctx = await self._context.get()
-            if self.task_output_key not in final_ctx:
+
+            if self.task_output_key not in (final_ctx := await self._context.get()):
                 logger.warning(
                     f"Task output key: {self.task_output_key} not found in the context, None will be returned. You can check if `Action.output_key` is set the same as `WorkFlow.task_output_key`."
                 )

fabricatio/models/events.py

@@ -18,7 +18,7 @@ class Event(BaseModel):
     """ The segments of the namespaces."""
 
     @classmethod
-    def instantiate_from(cls, event: EventLike) -> Self:
+    def instantiate_from(cls, event: EventLike) -> "Event":
         """Create an Event instance from a string or list of strings or an Event instance.
 
         Args:
@@ -35,7 +35,7 @@ class Event(BaseModel):
         return cls(segments=event)
 
     @classmethod
-    def quick_instantiate(cls, event: EventLike) -> Self:
+    def quick_instantiate(cls, event: EventLike) -> "Event":
         """Create an Event instance from a string or list of strings or an Event instance and push a wildcard and pending segment.
 
         Args:
@@ -59,7 +59,7 @@ class Event(BaseModel):
 
     def clone(self) -> Self:
         """Clone the event."""
-        return Event(segments=list(self.segments))
+        return self.__class__(segments=list(self.segments))
 
     def push(self, segment: str) -> Self:
         """Push a segment to the event."""
@@ -113,6 +113,8 @@ class Event(BaseModel):
         """Return the hash of the event, using the collapsed string."""
         return hash(self.collapse())
 
-    def __eq__(self, other: str | List[str] | Self) -> bool:
+    def __eq__(self, other: object) -> bool:
         """Check if the event is equal to another event or a string."""
+        if not isinstance(other, (str , list , Event)):
+            return False
         return self.collapse() == Event.instantiate_from(other).collapse()

fabricatio/models/extra.py

@@ -2,43 +2,39 @@
 
 from typing import List
 
-from fabricatio.models.generic import Display, PrepareVectorization, ProposedAble
-from pydantic import BaseModel, ConfigDict, Field
+from fabricatio.models.generic import Base, Display, FinalizedDumpAble, PrepareVectorization, ProposedAble
+from pydantic import Field
 
 
-class Equation(BaseModel):
+class Equation(Base):
     """Structured representation of mathematical equations (including their physical or conceptual meanings)."""
 
-    model_config = ConfigDict(use_attribute_docstrings=True)
-
-    description: str = Field(...)
+    description: str
     """A concise explanation of the equation's meaning, purpose, and relevance in the context of the research."""
 
-    latex_code: str = Field(...)
+    latex_code: str
     """The LaTeX code used to represent the equation in a publication-ready format."""
 
 
-class Figure(BaseModel):
+class Figure(Base):
     """Structured representation of figures (including their academic significance and explanatory captions)."""
 
-    model_config = ConfigDict(use_attribute_docstrings=True)
-
-    description: str = Field(...)
+    description: str
     """A detailed explanation of the figure's content and its role in conveying key insights."""
 
-    figure_caption: str = Field(...)
+    figure_caption: str
     """The caption accompanying the figure, summarizing its main points and academic value."""
 
-    figure_path: str = Field(...)
+    figure_path: str
     """The file path to the figure"""
 
 
-class Highlightings(BaseModel):
+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."""
+    """Core mathematical equations that represent breakthroughs in the field, accompanied by explanations of their physical or conceptual significance,Should always be in LaTeX format wrapped in $ or $$ signs."""
 
     highlighted_algorithms: List[str] = Field(default_factory=list)
     """Pseudocode for key algorithms, annotated to highlight innovative components."""
@@ -57,40 +53,119 @@ class ArticleEssence(ProposedAble, Display, PrepareVectorization):
     title: str = Field(...)
     """The full title of the paper, including any subtitles if applicable."""
 
-    authors: List[str] = Field(default_factory=list)
+    authors: List[str]
     """A list of the paper's authors, typically in the order of contribution."""
 
-    keywords: List[str] = Field(default_factory=list)
+    keywords: List[str]
     """A list of keywords that summarize the paper's focus and facilitate indexing."""
 
-    publication_year: int = Field(None)
+    publication_year: int
     """The year in which the paper was published."""
 
     # Core Content Elements
-    domain: List[str] = Field(default_factory=list)
+    highlightings: Highlightings = Field(default_factory=Highlightings)
+    """A collection of highlighted elements in the paper, including equations, algorithms, figures, and tables."""
+
+    domain: List[str]
     """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)
+    core_contributions: List[str]
     """Key academic contributions that distinguish the paper from prior work in the field."""
 
-    technical_novelty: List[str] = Field(default_factory=list)
+    technical_novelty: List[str]
     """Specific technical innovations introduced by the research, listed as individual points."""
 
     # Academic Discussion Dimensions
-    research_problem: str = Field("")
+    research_problems: List[str]
     """A clearly defined research question or problem addressed by the study."""
 
-    limitations: List[str] = Field(default_factory=list)
+    limitations: List[str]
     """An analysis of the methodological or experimental limitations of the research."""
 
-    future_work: List[str] = Field(default_factory=list)
+    future_work: List[str]
     """Suggestions for potential directions or topics for follow-up studies."""
 
-    impact_analysis: str = Field("")
+    impact_analysis: List[str]
     """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)

fabricatio/models/generic.py

@@ -2,7 +2,7 @@
 
 from abc import abstractmethod
 from pathlib import Path
-from typing import Callable, 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
@@ -67,6 +67,18 @@ class WithBriefing(Named, Described):
         """
         return f"{self.name}: {self.description}" if self.description else self.name
 
+    def prepend[D: Dict[str, Any]](self, kwargs: D) -> D:
+        """Prepend the briefing to the system message in the kwargs.
+
+        Args:
+            kwargs (Dict[str, Any]): The keyword arguments to modify.
+
+        Returns:
+            Dict[str, Any]: The modified keyword arguments.
+        """
+        kwargs["system_message"] = f"# your personal briefing: \n{self.briefing}\n" + kwargs.get("system_message", "")
+        return kwargs
+
 
 class WithFormatedJsonSchema(Base):
     """Class that provides a formatted JSON schema of the model."""
@@ -87,8 +99,15 @@ class WithFormatedJsonSchema(Base):
 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:
@@ -97,10 +116,18 @@ class CreateJsonObjPrompt(WithFormatedJsonSchema):
         Returns:
             str: The prompt for creating a JSON object with given requirement.
         """
-        return template_manager.render_template(
+        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):
@@ -120,11 +147,35 @@ class InstantiateFromString(Base):
 
 
 class ProposedAble(CreateJsonObjPrompt, InstantiateFromString):
-    """Class that provides methods for proposing a task."""
+    """Class that provides a method to propose a JSON object based on the requirement."""
 
     pass
 
 
+class FinalizedDumpAble(Base):
+    """Class that provides a method to finalize the dump of the object."""
+
+    @abstractmethod
+    def finalized_dump(self) -> str:
+        """Finalize the dump of the object.
+
+        Returns:
+            str: The finalized dump of the object.
+        """
+
+    def finalized_dump_to(self, path: str | Path) -> Self:
+        """Finalize the dump of the object to a file.
+
+        Args:
+            path (str | Path): The path to save the finalized dump.
+
+        Returns:
+            Self: The current instance of the object.
+        """
+        Path(path).write_text(self.finalized_dump(), encoding="utf-8")
+        return self
+
+
 class WithDependency(Base):
     """Class that manages file dependencies."""
 
@@ -337,3 +388,4 @@ class ScopedConfig(Base):
             for attr_name in ScopedConfig.model_fields:
                 if (attr := getattr(self, attr_name)) is not None and getattr(other, attr_name) is None:
                     setattr(other, attr_name, attr)
+        return self