fabricatio 0.3.15.dev4__cp313-cp313-win_amd64.whl → 0.4.0__cp313-cp313-win_amd64.whl

fabricatio/fs/curd.py

@@ -1,153 +0,0 @@
-"""File system create, update, read, delete operations."""
-
-import shutil
-import subprocess
-from os import PathLike
-from pathlib import Path
-from typing import Union
-
-from fabricatio.decorators import depend_on_external_cmd
-from fabricatio.journal import logger
-
-
-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.
-
-    Args:
-        path(str, Path): Path to the file
-        text(str): Text to write to the file
-
-    Returns:
-        None
-    """
-    Path(path).write_text(text, encoding="utf-8", errors="ignore", newline="\n")
-
-
-def copy_file(src: Union[str, Path], dst: Union[str, Path]) -> None:
-    """Copy a file from source to destination.
-
-    Args:
-        src: Source file path
-        dst: Destination file path
-
-    Raises:
-        FileNotFoundError: If source file doesn't exist
-        shutil.SameFileError: If source and destination are the same
-    """
-    try:
-        shutil.copy(src, dst)
-        logger.info(f"Copied file from {src} to {dst}")
-    except OSError as e:
-        logger.error(f"Failed to copy file from {src} to {dst}: {e!s}")
-        raise
-
-
-def move_file(src: Union[str, Path], dst: Union[str, Path]) -> None:
-    """Move a file from source to destination.
-
-    Args:
-        src: Source file path
-        dst: Destination file path
-
-    Raises:
-        FileNotFoundError: If source file doesn't exist
-        shutil.SameFileError: If source and destination are the same
-    """
-    try:
-        shutil.move(src, dst)
-        logger.info(f"Moved file from {src} to {dst}")
-    except OSError as e:
-        logger.error(f"Failed to move file from {src} to {dst}: {e!s}")
-        raise
-
-
-def delete_file(file_path: Union[str, Path]) -> None:
-    """Delete a file.
-
-    Args:
-        file_path: Path to the file to be deleted
-
-    Raises:
-        FileNotFoundError: If file doesn't exist
-        PermissionError: If no permission to delete the file
-    """
-    try:
-        Path(file_path).unlink()
-        logger.info(f"Deleted file: {file_path}")
-    except OSError as e:
-        logger.error(f"Failed to delete file {file_path}: {e!s}")
-        raise
-
-
-def create_directory(dir_path: Union[str, Path], parents: bool = True, exist_ok: bool = True) -> None:
-    """Create a directory.
-
-    Args:
-        dir_path: Path to the directory to create
-        parents: Create parent directories if they don't exist
-        exist_ok: Don't raise error if directory already exists
-    """
-    try:
-        Path(dir_path).mkdir(parents=parents, exist_ok=exist_ok)
-        logger.info(f"Created directory: {dir_path}")
-    except OSError as e:
-        logger.error(f"Failed to create directory {dir_path}: {e!s}")
-        raise
-
-
-@depend_on_external_cmd(
-    "erd",
-    "Please install `erd` using `cargo install erdtree` or `scoop install erdtree`.",
-    "https://github.com/solidiquis/erdtree",
-)
-def tree(dir_path: Union[str, Path]) -> str:
-    """Generate a tree representation of the directory structure. Requires `erd` to be installed."""
-    dir_path = Path(dir_path)
-    return subprocess.check_output(("erd", dir_path.as_posix()), encoding="utf-8")  # noqa: S603
-
-
-def delete_directory(dir_path: Union[str, Path]) -> None:
-    """Delete a directory and its contents.
-
-    Args:
-        dir_path: Path to the directory to delete
-
-    Raises:
-        FileNotFoundError: If directory doesn't exist
-        OSError: If directory is not empty and can't be removed
-    """
-    try:
-        shutil.rmtree(dir_path)
-        logger.info(f"Deleted directory: {dir_path}")
-    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.
-
-    Example:
-        >>> gather_files('/path/to/directory', 'txt')
-        ['/path/to/directory/file1.txt', '/path/to/directory/file2.txt']
-    """
-    return [file.as_posix() for file in Path(directory).rglob(f"*.{extension}")]

fabricatio/fs/readers.py

@@ -1,61 +0,0 @@
-"""Filesystem readers for Fabricatio."""
-
-import re
-from pathlib import Path
-from typing import Dict, List, Tuple
-
-import ujson
-
-from fabricatio.journal import logger
-
-
-def safe_text_read(path: Path | str) -> str:
-    """Safely read the text from a file.
-
-    Args:
-        path (Path|str): The path to the file.
-
-    Returns:
-        str: The text from the file.
-    """
-    path = Path(path)
-    try:
-        return path.read_text(encoding="utf-8")
-    except (UnicodeDecodeError, IsADirectoryError, FileNotFoundError) as e:
-        logger.error(f"Failed to read file {path}: {e!s}")
-        return ""
-
-
-def safe_json_read(path: Path | str) -> Dict:
-    """Safely read the JSON from a file.
-
-    Args:
-        path (Path|str): The path to the file.
-
-    Returns:
-        dict: The JSON from the file.
-    """
-    path = Path(path)
-    try:
-        return ujson.loads(path.read_text(encoding="utf-8"))
-    except (ujson.JSONDecodeError, IsADirectoryError, FileNotFoundError) as e:
-        logger.error(f"Failed to read file {path}: {e!s}")
-        return {}
-
-
-def extract_sections(string: str, level: int, section_char: str = "#") -> List[Tuple[str, str]]:
-    """Extract sections from markdown-style text by header level.
-
-    Args:
-        string (str): Input text to parse
-        level (int): Header level (e.g., 1 for '#', 2 for '##')
-        section_char (str, optional): The character used for headers (default: '#')
-
-    Returns:
-        List[Tuple[str, str]]: List of (header_text, section_content) tuples
-    """
-    return re.findall(
-        r"^%s{%d}\s+(.+?)\n((?:(?!^%s{%d}\s).|\n)*)" % (section_char, level, section_char, level),
-        string,
-        re.MULTILINE,
-    )

fabricatio/journal.py

@@ -1,12 +0,0 @@
-"""Logging setup for the project."""
-
-import sys
-
-from loguru import logger
-
-from fabricatio.rust import CONFIG
-
-logger.remove()
-logger.add(sys.stderr, level=CONFIG.debug.log_level)
-
-__all__ = ["logger"]

fabricatio/models/action.py

@@ -1,263 +0,0 @@
-"""Module that contains the classes for defining and executing task workflows.
-
-This module provides the Action and WorkFlow classes for creating structured
-task execution pipelines. Actions represent atomic operations, while WorkFlows
-orchestrate sequences of actions with shared context and error handling.
-
-Classes:
-    Action: Base class for defining executable actions with context management.
-    WorkFlow: Manages action sequences, context propagation, and task lifecycle.
-"""
-
-import traceback
-from abc import abstractmethod
-from asyncio import Queue, create_task
-from typing import Any, ClassVar, Dict, Generator, Self, Sequence, Tuple, Type, Union, final
-
-from fabricatio.journal import logger
-from fabricatio.models.generic import WithBriefing
-from fabricatio.models.task import Task
-from fabricatio.utils import override_kwargs
-from pydantic import Field, PrivateAttr
-
-OUTPUT_KEY = "task_output"
-
-INPUT_KEY = "task_input"
-
-
-class Action(WithBriefing):
-    """Class that represents an action to be executed in a workflow.
-
-    Actions are the atomic units of work in a workflow. Each action performs
-    a specific operation and can modify the shared context data.
-    """
-
-    ctx_override: ClassVar[bool] = False
-    """Whether to override the instance attr by the context variable."""
-
-    name: str = Field(default="")
-    """The name of the action."""
-
-    description: str = Field(default="")
-    """The description of the action."""
-
-    personality: str = Field(default="")
-    """The personality traits or context for the action executor."""
-
-    output_key: str = Field(default="")
-    """The key used to store this action's output in the context dictionary."""
-
-    @final
-    def model_post_init(self, __context: Any) -> None:
-        """Initialize the action by setting default name and description 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, *_: Any, **cxt) -> Any:
-        """Implement the core logic of the action.
-
-        Args:
-            **cxt: Context dictionary containing input/output data.
-
-        Returns:
-            Result of the action execution to be stored in context.
-        """
-        pass
-
-    @final
-    async def act(self, cxt: Dict[str, Any]) -> Dict[str, Any]:
-        """Execute action and update context.
-
-        Args:
-            cxt (Dict[str, Any]): Shared context dictionary.
-
-        Returns:
-            Updated context dictionary with new/modified entries.
-        """
-        ret = await self._execute(**cxt)
-
-        if self.output_key:
-            logger.debug(f"Setting output: {self.output_key}")
-            cxt[self.output_key] = ret
-
-        return cxt
-
-    @property
-    def briefing(self) -> str:
-        """Generate formatted action description with personality context.
-
-        Returns:
-            Briefing text combining personality and action description.
-        """
-        if self.personality:
-            return f"## Your personality: \n{self.personality}\n# The action you are going to perform: \n{super().briefing}"
-        return f"# The action you are going to perform: \n{super().briefing}"
-
-    def to_task_output(self, to: Union[str, "WorkFlow"] = OUTPUT_KEY) -> Self:
-        """Set the output key to OUTPUT_KEY and return the action instance."""
-        self.output_key = to.task_output_key if isinstance(to, WorkFlow) else to
-        return self
-
-
-class WorkFlow(WithBriefing):
-    """Manages sequences of actions to fulfill tasks.
-
-    Handles context propagation between actions, error handling, and task lifecycle
-    events like cancellation and completion.
-    """
-
-    name: str = "WorkFlow"
-    """The name of the workflow, which is used to identify and describe the workflow."""
-    description: str = ""
-    """The description of the workflow, which describes the workflow's purpose and requirements."""
-
-    _context: Queue[Dict[str, Any]] = PrivateAttr(default_factory=lambda: Queue(maxsize=1))
-    """Queue for storing the workflow execution context."""
-
-    _instances: Tuple[Action, ...] = PrivateAttr(default_factory=tuple)
-    """Instantiated action objects to be executed in this workflow."""
-
-    steps: Sequence[Union[Type[Action], Action]] = Field(frozen=True)
-    """The sequence of actions to be executed, can be action classes or instances."""
-
-    task_input_key: ClassVar[str] = INPUT_KEY
-    """Key used to store the input task in the context dictionary."""
-
-    task_output_key: ClassVar[str] = OUTPUT_KEY
-    """Key used to extract the final result from the context dictionary."""
-
-    extra_init_context: Dict[str, Any] = Field(default_factory=dict, frozen=True)
-    """Additional initial context values to be included at workflow start."""
-
-    def model_post_init(self, __context: Any) -> None:
-        """Initialize the workflow by instantiating any action classes.
-
-        Args:
-            __context: The context to be used for initialization.
-
-        """
-        self.name = self.name or self.__class__.__name__
-        # Convert any action classes to instances
-        self._instances = tuple(step if isinstance(step, Action) else step() for step in self.steps)
-
-    def iter_actions(self) -> Generator[Action, None, None]:
-        """Iterate over action instances."""
-        yield from self._instances
-
-    def inject_personality(self, personality: str) -> Self:
-        """Set personality for actions without existing personality.
-
-        Args:
-            personality (str): Shared personality context
-
-        Returns:
-            Workflow instance with updated actions
-        """
-        for action in filter(lambda a: not a.personality, self._instances):
-            action.personality = personality
-        return self
-
-    def override_action_variable(self, action: Action, ctx: Dict[str, Any]) -> Self:
-        """Override action variable with context values."""
-        if action.ctx_override:
-            for k, v in ctx.items():
-                if hasattr(action, k):
-                    setattr(action, k, v)
-
-        return self
-
-    async def serve(self, task: Task) -> None:
-        """Execute workflow to complete given task.
-
-        Args:
-            task (Task): Task instance to be processed.
-
-        Steps:
-            1. Initialize context with task instance and extra data
-            2. Execute each action sequentially
-            3. Handle task cancellation and exceptions
-            4. Extract final result from context
-        """
-        logger.info(f"Start execute workflow: {self.name}")
-
-        await task.start()
-        await self._init_context(task)
-
-        current_action = None
-        try:
-            # Process each action in sequence
-            for i, step in enumerate(self._instances):
-                logger.info(f"Executing step [{i}] >> {(current_action := step.name)}")
-
-                # Get current context and execute action
-                context = await self._context.get()
-
-                self.override_action_variable(step, context)
-                act_task = create_task(step.act(context))
-                # Handle task cancellation
-                if task.is_cancelled():
-                    logger.warning(f"Workflow cancelled by task: {task.name}")
-                    act_task.cancel(f"Cancelled by task: {task.name}")
-                    break
-
-                # Update context with modified values
-                modified_ctx = await act_task
-                logger.success(f"Step [{i}] `{current_action}` execution finished.")
-                if step.output_key:
-                    logger.success(f"Setting action `{current_action}` output to `{step.output_key}`")
-                await self._context.put(modified_ctx)
-
-            logger.success(f"Workflow `{self.name}` execution finished.")
-
-            # Get final context and extract result
-            final_ctx = await self._context.get()
-            result = final_ctx.get(self.task_output_key)
-
-            if self.task_output_key not in final_ctx:
-                logger.warning(
-                    f"Task output key: `{self.task_output_key}` not found in the context, None will be returned. "
-                    f"You can check if `Action.output_key` is set the same as `WorkFlow.task_output_key`."
-                )
-
-            await task.finish(result)
-
-        except Exception as e:  # noqa: BLE001
-            logger.critical(f"Error during task: {current_action} execution: {e}")
-            logger.critical(traceback.format_exc())
-            await task.fail()
-
-    async def _init_context[T](self, task: Task[T]) -> None:
-        """Initialize workflow execution context.
-
-        Args:
-            task (Task[T]): Task being processed
-
-        Context includes:
-            - Task instance stored under task_input_key
-            - Any extra_init_context values
-        """
-        logger.debug(f"Initializing context for workflow: {self.name}")
-        ctx = override_kwargs(self.extra_init_context, **task.extra_init_context)
-        if self.task_input_key in ctx:
-            raise ValueError(
-                f"Task input key: `{self.task_input_key}`, which is reserved, is already set in the init context"
-            )
-
-        await self._context.put({self.task_input_key: task, **ctx})
-
-    def update_init_context(self, /, **kwargs) -> Self:
-        """Update the initial context with additional key-value pairs.
-
-        Args:
-            **kwargs: Key-value pairs to add to the initial context.
-
-        Returns:
-            Self: The workflow instance for method chaining.
-        """
-        self.extra_init_context.update(kwargs)
-        return self

fabricatio/models/adv_kwargs_types.py

@@ -1,63 +0,0 @@
-"""A module containing kwargs types for content correction and checking operations."""
-
-from importlib.util import find_spec
-from typing import NotRequired, Optional, TypedDict
-
-from fabricatio.models.extra.problem import Improvement
-from fabricatio.models.extra.rule import RuleSet
-from fabricatio.models.generic import SketchedAble
-from fabricatio.models.kwargs_types import ReferencedKwargs
-
-
-class CorrectKwargs[T: SketchedAble](ReferencedKwargs[T], total=False):
-    """Arguments for content correction operations.
-
-    Extends GenerateKwargs with parameters for correcting content based on
-    specific criteria and templates.
-    """
-
-    improvement: Improvement
-
-
-class CheckKwargs(ReferencedKwargs[Improvement], total=False):
-    """Arguments for content checking operations.
-
-    Extends GenerateKwargs with parameters for checking content against
-    specific criteria and templates.
-    """
-
-    ruleset: RuleSet
-
-
-if find_spec("pymilvus"):
-    from pymilvus import CollectionSchema
-    from pymilvus.milvus_client import IndexParams
-
-    class CollectionConfigKwargs(TypedDict, total=False):
-        """Configuration parameters for a vector collection.
-
-        These arguments are typically used when configuring connections to vector databases.
-        """
-
-        dimension: int | None
-        primary_field_name: str
-        id_type: str
-        vector_field_name: str
-        metric_type: str
-        timeout: float | None
-        schema: CollectionSchema | None
-        index_params: IndexParams | None
-
-    class FetchKwargs(TypedDict):
-        """Arguments for fetching data from vector collections.
-
-        Controls how data is retrieved from vector databases, including filtering
-        and result limiting parameters.
-        """
-
-        collection_name: NotRequired[str | None]
-        similarity_threshold: NotRequired[float]
-        result_per_query: NotRequired[int]
-        tei_endpoint: NotRequired[Optional[str]]
-        reranker_threshold: NotRequired[float]
-        filter_expr: NotRequired[str]

fabricatio/models/extra/__init__.py

@@ -1 +0,0 @@
-"""A module contains extra models for fabricatio."""

fabricatio/models/extra/advanced_judge.py

@@ -1,32 +0,0 @@
-"""Module containing the JudgeMent class for holding judgment results."""
-
-from typing import List
-
-from fabricatio.models.generic import SketchedAble
-
-
-class JudgeMent(SketchedAble):
-    """Represents a judgment result containing supporting/denying evidence and final verdict.
-
-    The class stores both affirmative and denies evidence, truth and reasons lists along with the final boolean judgment.
-    """
-
-    issue_to_judge: str
-    """The issue to be judged, including the original question and context"""
-
-    deny_evidence: List[str]
-    """List of clues supporting the denial."""
-
-    affirm_evidence: List[str]
-    """List of clues supporting the affirmation."""
-
-    final_judgement: bool
-    """The final judgment made according to all extracted clues. true for the `issue_to_judge` is correct and false for incorrect."""
-
-    def __bool__(self) -> bool:
-        """Return the final judgment value.
-
-        Returns:
-            bool: The stored final_judgement value indicating the judgment result.
-        """
-        return self.final_judgement