fabricatio 0.2.8.dev2__cp312-cp312-win_amd64.whl → 0.2.8.dev4__cp312-cp312-win_amd64.whl

fabricatio/models/generic.py

@@ -6,13 +6,15 @@ from pathlib import Path
 from typing import Any, Callable, Dict, Iterable, List, Optional, Self, Union, final, overload
 
 import orjson
+import rtoml
 from fabricatio._rust import blake3_hash
 from fabricatio._rust_instances import TEMPLATE_MANAGER
 from fabricatio.config import configs
 from fabricatio.fs.readers import MAGIKA, safe_text_read
 from fabricatio.journal import logger
-from fabricatio.models.utils import ok
 from fabricatio.parser import JsonCapture
+from fabricatio.utils import ok
+from litellm.utils import token_counter
 from pydantic import (
     BaseModel,
     ConfigDict,
@@ -52,6 +54,11 @@ class Display(Base):
         """
         return self.model_dump_json()
 
+    @staticmethod
+    def seq_display(seq: Iterable["Display"], compact: bool = False) -> str:
+        """Display a sequence of Display objects in a formatted JSON string."""
+        return "\n".join(d.compact() if compact else d.display() for d in seq)
+
 
 class Named(Base):
     """Class that includes a name attribute."""
@@ -63,7 +70,7 @@ class Named(Base):
 class Described(Base):
     """Class that includes a description attribute."""
 
-    description: str = Field(default="", frozen=True)
+    description: str = Field(frozen=True)
     """The description of the object."""
 
 
@@ -98,14 +105,28 @@ class WithRef[T](Base):
             self._reference, f"`{self.__class__.__name__}`' s `_reference` field is None. Have you called `update_ref`?"
         )
 
-    def update_ref[S: "WithRef"](self: S, reference: T | S) -> S:  # noqa: PYI019
+    @overload
+    def update_ref[S: WithRef](self: S, reference: T) -> S: ...
+
+    @overload
+    def update_ref[S: WithRef](self: S, reference: "WithRef[T]") -> S: ...
+
+    @overload
+    def update_ref[S: WithRef](self: S, reference: None = None) -> S: ...
+    def update_ref[S: WithRef](self: S, reference: Union[T, "WithRef[T]", None] = None) -> S:  # noqa: PYI019
         """Update the reference of the object."""
         if isinstance(reference, self.__class__):
             self._reference = reference.referenced
         else:
-            self._reference = reference
+            self._reference = reference  # pyright: ignore [reportAttributeAccessIssue]
         return self
 
+    def derive[S: WithRef](self: S, reference: Any) -> S:  # noqa: PYI019
+        """Derive a new object from the current object."""
+        new = self.model_copy()
+        new._reference = reference
+        return new
+
 
 class PersistentAble(Base):
     """Class that provides a method to persist the object."""
@@ -120,10 +141,10 @@ class PersistentAble(Base):
             Self: The current instance of the object.
         """
         p = Path(path)
-        out = self.model_dump_json(indent=1)
+        out = self.model_dump_json()
 
         # Generate a timestamp in the format YYYYMMDD_HHMMSS
-        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        timestamp = datetime.now().strftime("%Y%m%d")
 
         # Generate the hash
         file_hash = blake3_hash(out.encode())[:6]
@@ -150,7 +171,7 @@ class PersistentAble(Base):
         Returns:
             Self: The current instance of the object.
         """
-        return cls.model_validate_json(Path(path).read_text(encoding="utf-8"))
+        return cls.model_validate_json(safe_text_read(path))
 
 
 class ModelHash(Base):
@@ -220,27 +241,6 @@ class WithBriefing(Named, Described):
         """
         return f"{self.name}: {self.description}" if self.description else self.name
 
-    def _prepend_inner(self, input_text: str) -> str:
-        return f"# your personal briefing: \n{self.briefing}\n{input_text}"
-
-    def prepend_sys_msg[D: (Dict[str, Any], str)](self, system_msg_like: D = "") -> Dict[str, Any]:
-        """Prepend the system message with the briefing.
-
-        Args:
-            system_msg_like (str | dict): The system message or a dictionary containing the system message.
-
-        Returns:
-            dict: The system message with the briefing prepended.
-        """
-        match system_msg_like:
-            case dict(d):
-                d["system_message"] = self._prepend_inner(d.get("system_message", ""))
-                return d
-            case str(s):
-                return {"system_message": self._prepend_inner(s)}
-            case _:
-                raise TypeError(f"{system_msg_like} is not a dict or str")
-
 
 class UnsortGenerate(GenerateJsonSchema):
     """Class that provides a reverse JSON schema of the model."""
@@ -314,14 +314,20 @@ class InstantiateFromString(Base):
         Returns:
             Self | None: The instance of the class or None if the string is not valid.
         """
-        return JsonCapture.convert_with(string, cls.model_validate_json)
+        obj = JsonCapture.convert_with(string, cls.model_validate_json)
+        logger.debug(f"Instantiate `{cls.__name__}` from string, {'Failed' if obj is None else 'Success'}.")
+        return obj
 
 
 class ProposedAble(CreateJsonObjPrompt, InstantiateFromString):
     """Class that provides a method to propose a JSON object based on the requirement."""
 
 
-class ProposedUpdateAble(ProposedAble, UpdateFrom, ABC):
+class SketchedAble(ProposedAble, Display):
+    """Class that provides a method to scratch the object."""
+
+
+class ProposedUpdateAble(SketchedAble, UpdateFrom, ABC):
     """Make the obj can be updated from the proposed obj in place."""
 
 
@@ -349,8 +355,6 @@ class FinalizedDumpAble(Base):
         return self
 
 
-class CensoredAble(ProposedAble, FinalizedDumpAble):
-    """Class that provides a method to censor the object."""
 
 
 class WithDependency(Base):
@@ -441,13 +445,13 @@ class WithDependency(Base):
         )
 
 
-class PrepareVectorization(Base):
+class Vectorizable(Base):
     """Class that prepares the vectorization of the model."""
 
-    @abstractmethod
     def _prepare_vectorization_inner(self) -> str:
-        """Prepare the vectorization of the model."""
+        return rtoml.dumps(self.model_dump())
 
+    @final
     def prepare_vectorization(self, max_length: Optional[int] = None) -> str:
         """Prepare the vectorization of the model.
 
@@ -456,8 +460,8 @@ class PrepareVectorization(Base):
         """
         max_length = max_length or configs.embedding.max_sequence_length
         chunk = self._prepare_vectorization_inner()
-        if max_length and len(chunk) > max_length:
-            logger.error(err := f"Chunk exceeds maximum sequence length {max_length}.")
+        if max_length and (length := token_counter(text=chunk)) > max_length:
+            logger.error(err := f"Chunk exceeds maximum sequence length {max_length}, got {length},see {chunk}")
             raise ValueError(err)
 
         return chunk
@@ -572,3 +576,33 @@ class ScopedConfig(Base):
                 if (attr := getattr(self, attr_name)) is not None and getattr(other, attr_name) is None:
                     setattr(other, attr_name, attr)
         return self
+
+
+class Patch[T](ProposedAble):
+    """Base class for patches."""
+
+    def apply(self, other: T) -> T:
+        """Apply the patch to another instance."""
+        for field in self.__class__.model_fields:
+            if not hasattr(other, field):
+                raise ValueError(f"{field} not found in {other}, are you applying to the wrong type?")
+            setattr(other, field, getattr(self, field))
+        return other
+
+
+class SequencePatch[T](ProposedUpdateAble):
+    """Base class for patches."""
+
+    tweaked: List[T]
+    """Tweaked content list"""
+
+    def update_from_inner(self, other: Self) -> Self:
+        """Updates the current instance with the attributes of another instance."""
+        self.tweaked.clear()
+        self.tweaked.extend(other.tweaked)
+        return self
+
+    @classmethod
+    def default(cls) -> Self:
+        """Defaults to empty list."""
+        return cls(tweaked=[])

fabricatio/models/kwargs_types.py

@@ -1,7 +1,7 @@
 """This module contains the types for the keyword arguments of the methods in the models module."""
 
 from importlib.util import find_spec
-from typing import Any, Dict, Required, TypedDict
+from typing import Any, Dict, List, Optional, Required, TypedDict
 
 from litellm.caching.caching import CacheMode
 from litellm.types.caching import CachingSupportedCallTypes
@@ -95,11 +95,30 @@ class ValidateKwargs[T](GenerateKwargs, total=False):
     such as limiting the number of validation attempts.
     """
 
-    default: T
+    default: Optional[T]
     max_validations: int
     co_extractor: GenerateKwargs
 
 
+class CompositeScoreKwargs(ValidateKwargs[List[Dict[str, float]]], total=False):
+    """Arguments for composite score generation operations.
+
+    Extends GenerateKwargs with parameters for generating composite scores
+    based on specific criteria and weights.
+    """
+
+    topic: str
+    criteria: set[str]
+    weights: Dict[str, float]
+    manual: Dict[str, str]
+
+
+class BestKwargs(CompositeScoreKwargs, total=False):
+    """Arguments for choose top-k operations."""
+
+    k: int
+
+
 class ReviewInnerKwargs[T](ValidateKwargs[T], total=False):
     """Arguments for content review operations."""
 
@@ -118,22 +137,9 @@ class ReviewKwargs[T](ReviewInnerKwargs[T], total=False):
     topic: Required[str]
 
 
-class CorrectKwargs[T](ReviewKwargs[T], total=False):
-    """Arguments for content correction operations.
-
-    Extends GenerateKwargs with parameters for correcting content based on
-    specific criteria and templates.
-    """
-
-    reference: str
-    supervisor_check: bool
-
-
-class CensoredCorrectKwargs[T](ReviewInnerKwargs[T], total=False):
-    """Arguments for content censorship operations."""
-
+class ReferencedKwargs[T](ValidateKwargs[T], total=False):
+    """Arguments for content review operations."""
     reference: str
-    supervisor_check: bool
 
 
 # noinspection PyTypedDict

fabricatio/models/role.py

@@ -8,11 +8,12 @@ from fabricatio.core import env
 from fabricatio.journal import logger
 from fabricatio.models.action import WorkFlow
 from fabricatio.models.events import Event
+from fabricatio.models.generic import WithBriefing
 from fabricatio.models.tool import ToolBox
 from pydantic import Field
 
 
-class Role(ProposeTask, HandleTask, Correct):
+class Role(WithBriefing, ProposeTask, HandleTask, Correct):
     """Class that represents a role with a registry of events and workflows.
 
     A Role serves as a container for workflows, managing their registration to events
@@ -22,6 +23,8 @@ class Role(ProposeTask, HandleTask, Correct):
         registry: Mapping of events to workflows that handle them
         toolboxes: Set of toolboxes available to this role and its workflows
     """
+    description:str =""
+    """A brief description of the role's responsibilities and capabilities."""
 
     registry: dict[Event | str, WorkFlow] = Field(default_factory=dict)
     """The registry of events and workflows."""

fabricatio/models/usages.py

@@ -2,7 +2,7 @@
 
 import traceback
 from asyncio import gather
-from typing import Callable, Dict, Iterable, List, Optional, Self, Sequence, Set, Type, Union, Unpack, overload
+from typing import Callable, Dict, Iterable, List, Optional, Self, Sequence, Set, Union, Unpack, overload
 
 import asyncstdlib
 import litellm
@@ -14,8 +14,9 @@ from fabricatio.models.generic import ScopedConfig, WithBriefing
 from fabricatio.models.kwargs_types import ChooseKwargs, EmbeddingKwargs, GenerateKwargs, LLMKwargs, ValidateKwargs
 from fabricatio.models.task import Task
 from fabricatio.models.tool import Tool, ToolBox
-from fabricatio.models.utils import Messages, ok
+from fabricatio.models.utils import Messages
 from fabricatio.parser import GenericCapture, JsonCapture
+from fabricatio.utils import ok
 from litellm import RateLimitError, Router, stream_chunk_builder  # pyright: ignore [reportPrivateImportUsage]
 from litellm.types.router import Deployment, LiteLLM_Params, ModelInfo
 from litellm.types.utils import (
@@ -52,10 +53,6 @@ class LLMUsage(ScopedConfig):
         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,
@@ -280,7 +277,7 @@ class LLMUsage(ScopedConfig):
         question: str | List[str],
         validator: Callable[[str], T | None],
         default: Optional[T] = None,
-        max_validations: PositiveInt = 2,
+        max_validations: PositiveInt = 3,
         co_extractor: Optional[GenerateKwargs] = None,
         **kwargs: Unpack[GenerateKwargs],
     ) -> Optional[T] | List[Optional[T]] | List[T] | T:
@@ -302,12 +299,11 @@ class LLMUsage(ScopedConfig):
         async def _inner(q: str) -> Optional[T]:
             for lap in range(max_validations):
                 try:
-                    if (
-                        (response := await self.aask(question=q, **kwargs))
-                        or (
-                            co_extractor
-                            and (
-                                response := await self.aask(
+                    if ((validated := validator(response := await self.aask(question=q, **kwargs))) is not None) or (
+                        co_extractor
+                        and (
+                            validated := validator(
+                                await self.aask(
                                     question=(
                                         TEMPLATE_MANAGER.render_template(
                                             configs.templates.co_validation_template,
@@ -318,7 +314,8 @@ class LLMUsage(ScopedConfig):
                                 )
                             )
                         )
-                    ) and (validated := validator(response)):
+                        is not None
+                    ):
                         logger.debug(f"Successfully validated the response at {lap}th attempt.")
                         return validated
 
@@ -338,7 +335,7 @@ class LLMUsage(ScopedConfig):
 
         return await (gather(*[_inner(q) for q in question]) if isinstance(question, list) else _inner(question))
 
-    async def aliststr(
+    async def alist_str(
         self, requirement: str, k: NonNegativeInt = 0, **kwargs: Unpack[ValidateKwargs[List[str]]]
     ) -> Optional[List[str]]:
         """Asynchronously generates a list of strings based on a given requirement.
@@ -370,7 +367,7 @@ class LLMUsage(ScopedConfig):
         Returns:
             List[str]: The validated response as a list of strings.
         """
-        return await self.aliststr(
+        return await self.alist_str(
             TEMPLATE_MANAGER.render_template(
                 configs.templates.pathstr_template,
                 {"requirement": requirement},
@@ -550,8 +547,8 @@ class EmbeddingUsage(LLMUsage):
         """
         # check seq length
         max_len = self.embedding_max_sequence_length or configs.embedding.max_sequence_length
-        if max_len and any(len(t) > max_len for t in input_text):
-            logger.error(err := f"Input text exceeds maximum sequence length {max_len}.")
+        if max_len and any(length := (token_counter(text=t)) > max_len for t in input_text):
+            logger.error(err := f"Input text exceeds maximum sequence length {max_len}, got {length}.")
             raise ValueError(err)
 
         return await litellm.aembedding(
@@ -712,7 +709,7 @@ class ToolBoxUsage(LLMUsage):
         """
         if isinstance(others, ToolBoxUsage):
             others = [others]
-        for other in others:
+        for other in (x for x in others if isinstance(x, ToolBoxUsage)):
             self.toolboxes.update(other.toolboxes)
         return self
 
@@ -728,6 +725,6 @@ class ToolBoxUsage(LLMUsage):
         """
         if isinstance(others, ToolBoxUsage):
             others = [others]
-        for other in others:
+        for other in (x for x in others if isinstance(x, ToolBoxUsage)):
             other.toolboxes.update(self.toolboxes)
         return self

fabricatio/models/utils.py

@@ -4,7 +4,6 @@ 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):
@@ -147,48 +146,3 @@ class TaskStatus(Enum):
     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
-
-
-def override_kwargs[T](kwargs: Dict[str, T], **overrides) -> Dict[str, T]:
-    """Override the values in kwargs with the provided overrides."""
-    kwargs.update({k: v for k, v in overrides.items() if v is not None})
-    return kwargs
-
-
-def fallback_kwargs[T](kwargs: Dict[str, T], **overrides) -> Dict[str, T]:
-    """Fallback the values in kwargs with the provided overrides."""
-    kwargs.update({k: v for k, v in overrides.items() if k not in kwargs})
-    return kwargs
-
-
-def ok[T](val: Optional[T], msg: str = "Value is None") -> T:
-    """Check if a value is None and raise a ValueError with the provided message if it is.
-
-    Args:
-        val: The value to check.
-        msg: The message to include in the ValueError if val is None.
-
-    Returns:
-        T: The value if it is not None.
-    """
-    if val is None:
-        raise ValueError(msg)
-    return val

fabricatio/parser.py

@@ -45,14 +45,14 @@ class Capture(BaseModel):
             str | List[str]: The fixed text with the same type as input.
         """
         match self.capture_type:
-            case "json":
+            case "json" if configs.general.use_json_repair:
+                logger.debug("Applying json repair to text.")
                 if isinstance(text, str):
                     return repair_json(text, ensure_ascii=False)
                 return [repair_json(item, ensure_ascii=False) for item in text]
             case _:
                 return text
 
-
     def capture(self, text: str) -> Tuple[str, ...] | str | None:
         """Capture the first occurrence of the pattern in the given text.
 
@@ -63,11 +63,10 @@ class Capture(BaseModel):
             str | None: The captured text if the pattern is found, otherwise None.
 
         """
-        match = self._compiled.search(text)
-        if match is None:
-            logger.debug(f"Capture Failed: \n{text}")
+        if (match :=self._compiled.match(text) or self._compiled.search(text) ) is None:
+            logger.debug(f"Capture Failed {type(text)}: \n{text}")
             return None
-        groups = self.fix(match.groups()) if configs.general.use_json_repair else match.groups()
+        groups = self.fix(match.groups())
         if self.target_groups:
             cap = tuple(groups[g - 1] for g in self.target_groups)
             logger.debug(f"Captured text: {'\n\n'.join(cap)}")
@@ -134,7 +133,7 @@ class Capture(BaseModel):
         Returns:
             Self: The instance of the class with the captured code block.
         """
-        return cls(pattern=f"```{language}\n(.*?)\n```", capture_type=language)
+        return cls(pattern=f"```{language}(.*?)```", capture_type=language)
 
     @classmethod
     def capture_generic_block(cls, language: str) -> Self:
@@ -143,7 +142,7 @@ class Capture(BaseModel):
         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)
+        return cls(pattern=f"--- Start of {language} ---(.*?)--- end of {language} ---", capture_type=language)
 
 
 JsonCapture = Capture.capture_code_block("json")

fabricatio/utils.py

@@ -0,0 +1,54 @@
+"""A collection of utility functions for the fabricatio package."""
+
+from typing import Any, Dict, List, Optional
+
+from questionary import text
+
+
+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
+
+
+def override_kwargs(kwargs: Dict[str,Any], **overrides) -> Dict[str, Any]:
+    """Override the values in kwargs with the provided overrides."""
+    new_kwargs = kwargs.copy()
+    new_kwargs.update({k: v for k, v in overrides.items() if v is not None})
+    return new_kwargs
+
+
+def fallback_kwargs(kwargs: Dict[str, Any], **overrides) -> Dict[str, Any]:
+    """Fallback the values in kwargs with the provided overrides."""
+    new_kwargs = kwargs.copy()
+    new_kwargs.update({k: v for k, v in overrides.items() if k not in new_kwargs and v is not None})
+    return new_kwargs
+
+
+def ok[T](val: Optional[T], msg: str = "Value is None") -> T:
+    """Check if a value is None and raise a ValueError with the provided message if it is.
+
+    Args:
+        val: The value to check.
+        msg: The message to include in the ValueError if val is None.
+
+    Returns:
+        T: The value if it is not None.
+    """
+    if val is None:
+        raise ValueError(msg)
+    return val

{fabricatio-0.2.8.dev2.dist-info → fabricatio-0.2.8.dev4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fabricatio
-Version: 0.2.8.dev2
+Version: 0.2.8.dev4
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: 3.12
@@ -23,6 +23,7 @@ Requires-Dist: pymitter>=1.0.0
 Requires-Dist: questionary>=2.1.0
 Requires-Dist: regex>=2024.11.6
 Requires-Dist: rich>=13.9.4
+Requires-Dist: rtoml>=0.12.0
 Requires-Dist: pymilvus>=2.5.4 ; extra == 'rag'
 Requires-Dist: fabricatio[calc,plot,rag] ; extra == 'full'
 Requires-Dist: sympy>=1.13.3 ; extra == 'calc'

fabricatio-0.2.8.dev4.dist-info/RECORD

@@ -0,0 +1,56 @@
+fabricatio-0.2.8.dev4.dist-info/METADATA,sha256=m8008QWQ2qtSzryx4jr2DpTqfNQDyhBUscJQgQzmM0I,5288
+fabricatio-0.2.8.dev4.dist-info/WHEEL,sha256=jABKVkLC9kJr8mi_er5jOqpiQUjARSLXDUIIxDqsS50,96
+fabricatio-0.2.8.dev4.dist-info/licenses/LICENSE,sha256=do7J7EiCGbq0QPbMAL_FqLYufXpHnCnXBOuqVPwSV8Y,1088
+fabricatio/actions/article.py,sha256=i5-u5tCiJd7b_lQ4_vHjV57ZXDoUIAHmgD9QFoFaTuM,12787
+fabricatio/actions/article_rag.py,sha256=dkfskNqntVPi81Xm_NFdTQM8v2nR9FJIexzkK9rg-NU,4352
+fabricatio/actions/output.py,sha256=-FfTzXEHIb_zOT-j4T4b5ND96zHLDEGdjlmmPviIbiM,3754
+fabricatio/actions/rag.py,sha256=wb3vt-gS6fDHYJ57Yfu_OR0kpewT9vMqwtXsqXd42Kg,2735
+fabricatio/capabilities/advanced_judge.py,sha256=selB0Gwf1F4gGJlwBiRo6gI4KOUROgh3WnzO3mZFEls,706
+fabricatio/capabilities/censor.py,sha256=-FZTDFfqlIwqMd4hkKzEHAknlp2pH5sawXDQ-7XJcXA,3784
+fabricatio/capabilities/check.py,sha256=_4FS0kTa37A3M8Cjl1oVxp1j971W5O58NxmtsU1TizA,8005
+fabricatio/capabilities/correct.py,sha256=8ax8oa9e4EIzho-cTXku-Sy7rC1zrOdlo23ooDZEyuM,9178
+fabricatio/capabilities/propose.py,sha256=hkBeSlmcTdfYWT-ph6nlbtHXBozi_JXqXlWcnBy3W78,2007
+fabricatio/capabilities/rag.py,sha256=7xDxDEvhlmb7Y-mEquSgvlVIYpHsM2YFxA9LjRpVajo,17720
+fabricatio/capabilities/rating.py,sha256=3gBqmYpEpzKge4mpxclJ4f9Nl_MTnADjuj4uqxw2Ilo,17011
+fabricatio/capabilities/review.py,sha256=1MGyJudPxHVOQod_GYKJ7NyB3jOWuwZhqBP30hAZ5Z4,5061
+fabricatio/capabilities/task.py,sha256=JG9kD2n86FvZQIjqZq-aqw8j9jpuuDpEDKTJCB6HzX4,4416
+fabricatio/config.py,sha256=aA-wirVVfjRuk1AXj-l9UFQFaDEBtV3YnzQIwCPE_G0,17503
+fabricatio/core.py,sha256=VQ_JKgUGIy2gZ8xsTBZCdr_IP7wC5aPg0_bsOmjQ588,6458
+fabricatio/decorators.py,sha256=C0Gi7wcXC-0sWITqsSv3JdBGcgVJOlRvOt0FfO0aUsA,7554
+fabricatio/fs/curd.py,sha256=p8y0LGKgVDk-CWOlm37E6wg7RK6RCD6denKo-VsW28c,4763
+fabricatio/fs/readers.py,sha256=EZKN_AZdrp8DggJECP53QHw3uHeSDf-AwCAA_V7fNKU,1202
+fabricatio/fs/__init__.py,sha256=PCf0s_9KDjVfNw7AfPoJzGt3jMq4gJOfbcT4pb0D0ZY,588
+fabricatio/journal.py,sha256=stnEP88aUBA_GmU9gfTF2EZI8FS2OyMLGaMSTgK4QgA,476
+fabricatio/models/action.py,sha256=dZkPP-7DaJIOjsFYWnp6vcOObMgjvda1O2FjboSDYjo,9003
+fabricatio/models/adv_kwargs_types.py,sha256=dcYMLn6xcnWLZTLTBdtpgUZWi-VBeub721GzHRZFT1g,860
+fabricatio/models/events.py,sha256=QvlnS8FEELg6KNabcJMeh2GV_y0ZBzKOPphcteKYWYU,4183
+fabricatio/models/extra/advanced_judge.py,sha256=mi3KiB8FUuSYICzXPXKwVhCyRE1GL3gHLkwuc-4mh3c,999
+fabricatio/models/extra/article_base.py,sha256=1Fg3iWbod1TCU3nIJK9mOq_8K3oGBtSW03VUwi2I5tg,17058
+fabricatio/models/extra/article_essence.py,sha256=xd6j-PDqjhrMjgUmyfk6HqkyMLu-sS9feUo0sZ3QABY,2825
+fabricatio/models/extra/article_main.py,sha256=0Xj54pRxUw5Iaj9npYmHKT-ZMvEIBlZ6G1ysNJRgceM,8225
+fabricatio/models/extra/article_outline.py,sha256=jFbVgiwlo7rnwCGS6ToVgeMUOoRe99Edgbx95THR6z8,1450
+fabricatio/models/extra/article_proposal.py,sha256=L2kPvH1XCCQSNcI1KQU3ULGq7C24Y88ssugX43LgbsE,2043
+fabricatio/models/extra/patches.py,sha256=_yyyDbaQ8wkj6QP-NU-3I74HehFgwD889vD0SlCjynU,303
+fabricatio/models/extra/problem.py,sha256=KwYkc7kjoEG7cwj9C8sWLoZgtBqJVuxlU_7KkvtSgO0,5828
+fabricatio/models/extra/rule.py,sha256=_ThlHOViuHcJdAhc6qdEUHaFOevvQYHvH89STzucUyM,719
+fabricatio/models/generic.py,sha256=uuCwpG4DS5DwnZ-2lRMBDufWbKp_5x4yuh1eAFwkFKY,20682
+fabricatio/models/kwargs_types.py,sha256=sMDA85SoC1AOJ5k6qC8qUiUv0Ne0_5ThU9FZITRNen4,5673
+fabricatio/models/role.py,sha256=-CRcj5_M3_ciLPzwiNn92grBmwoSLQ-n4koVZiCNTBM,2953
+fabricatio/models/task.py,sha256=8NaR7ojQWyM740EDTqt9stwHKdrD6axCRpLKo0QzS-I,10492
+fabricatio/models/tool.py,sha256=kD0eB7OxO9geZOxO6JIKvCBeG-KOpRAkfRZqK_WGfW4,7105
+fabricatio/models/usages.py,sha256=UC-igtnfW0scIkedb5leZuuR4XoSZYI7kf1S0L418CU,31813
+fabricatio/models/utils.py,sha256=Ac5g-8ic6q_w7dhNuh-iiofpL1sqOACxbjPPTljP2LY,4417
+fabricatio/parser.py,sha256=UOSvXigEXK-eXsr3m3b7glOhbBWs4kDJTeTNyuqA9ic,6315
+fabricatio/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fabricatio/toolboxes/arithmetic.py,sha256=WLqhY-Pikv11Y_0SGajwZx3WhsLNpHKf9drzAqOf_nY,1369
+fabricatio/toolboxes/fs.py,sha256=l4L1CVxJmjw9Ld2XUpIlWfV0_Fu_2Og6d3E13I-S4aE,736
+fabricatio/toolboxes/__init__.py,sha256=KBJi5OG_pExscdlM7Bnt_UF43j4I3Lv6G71kPVu4KQU,395
+fabricatio/utils.py,sha256=QJR00IuclL2nNTSfpTNBRYJmNjc_DNXGtrYWjatWpq8,1681
+fabricatio/workflows/articles.py,sha256=G5HGRr-DHuYuEcfhFdFAuDvTTJ9aSU_UQ2yYXEjTMtM,1047
+fabricatio/workflows/rag.py,sha256=-YYp2tlE9Vtfgpg6ROpu6QVO8j8yVSPa6yDzlN3qVxs,520
+fabricatio/_rust.pyi,sha256=_N8Jw1DMOFAaoibSQolxkKZ07nCfJao7Z9qkojHtLy0,5104
+fabricatio/_rust_instances.py,sha256=2GwF8aVfYNemRI2feBzH1CZfBGno-XJJE5imJokGEYw,314
+fabricatio/__init__.py,sha256=SzBYsRhZeL77jLtfJEjmoHOSwHwUGyvMATX6xfndLDM,1135
+fabricatio/_rust.cp312-win_amd64.pyd,sha256=y_AwUxK1t-eJJnlDm9MowMbM8s_GzUXAPX5W9Ao_06U,1892352
+fabricatio-0.2.8.dev4.data/scripts/tdown.exe,sha256=OKVp-_Q3lDufrVIc_ZmFJRKukM6TGqWnMMs0YOXULQE,3402240
+fabricatio-0.2.8.dev4.dist-info/RECORD,,