fabricatio 0.2.13.dev3__cp312-cp312-win_amd64.whl → 0.3.14.dev0__cp312-cp312-win_amd64.whl

fabricatio/rust.pyi

@@ -10,9 +10,8 @@ Key Features:
 - Cryptographic utilities: BLAKE3 hashing.
 - Text utilities: Word boundary splitting and word counting.
 """
-
-from pathlib import Path
-from typing import Any, Dict, List, Optional, Tuple, overload
+from enum import StrEnum
+from typing import Any, Dict, List, Optional, Self, Tuple, overload, Union
 
 from pydantic import JsonValue
 
@@ -26,17 +25,6 @@ class TemplateManager:
     See: https://crates.io/crates/handlebars
     """
 
-    def __init__(
-            self, template_dirs: List[Path], suffix: Optional[str] = None, active_loading: Optional[bool] = None
-    ) -> None:
-        """Initialize the template manager.
-
-        Args:
-            template_dirs: List of directories containing template files
-            suffix: File extension for templates (defaults to 'hbs')
-            active_loading: Whether to enable dev mode for reloading templates on change
-        """
-
     @property
     def template_count(self) -> int:
         """Returns the number of currently loaded templates."""
@@ -431,13 +419,12 @@ def inplace_update(string: str, wrapper: str, new_body: str) -> Optional[str]:
 
     Returns:
         A new string with the content between wrappers replaced.
-        
+
     """
 
 
 def extract_body(string: str, wrapper: str) -> Optional[str]:
-    """
-    Extract the content between two occurrences of a wrapper string.
+    """Extract the content between two occurrences of a wrapper string.
 
     Args:
         string: The input string containing content wrapped by delimiter strings.
@@ -446,3 +433,434 @@ def extract_body(string: str, wrapper: str) -> Optional[str]:
     Returns:
         The content between the first two occurrences of the wrapper string if found, otherwise None.
     """
+
+
+class LLMConfig:
+    """LLM configuration structure.
+
+    Contains parameters for configuring Language Learning Models.
+    """
+
+    api_endpoint: Optional[str]
+    """API endpoint URL for the LLM service."""
+
+    api_key: Optional[SecretStr]
+    """Authentication key for the LLM service."""
+
+    timeout: Optional[int]
+    """Maximum time in seconds to wait for a response."""
+
+    max_retries: Optional[int]
+    """Number of retry attempts for failed requests."""
+
+    model: Optional[str]
+    """Name of the LLM model to use."""
+
+    temperature: Optional[float]
+    """Controls randomness in response generation (0.0-2.0)."""
+
+    stop_sign: Optional[List[str]]
+    """Sequence(s) that signal the LLM to stop generating tokens."""
+
+    top_p: Optional[float]
+    """Controls diversity via nucleus sampling (0.0-1.0)."""
+
+    generation_count: Optional[int]
+    """Number of completions to generate for each prompt."""
+
+    stream: Optional[bool]
+    """When true, responses are streamed as they're generated."""
+
+    max_tokens: Optional[int]
+    """Maximum number of tokens to generate in the response."""
+
+    rpm: Optional[int]
+    """Rate limit in requests per minute."""
+
+    tpm: Optional[int]
+    """Rate limit in tokens per minute."""
+
+    presence_penalty: Optional[float]
+    """Penalizes new tokens based on their presence in text so far (-2.0-2.0)."""
+
+    frequency_penalty: Optional[float]
+    """Penalizes new tokens based on their frequency in text so far (-2.0-2.0)."""
+
+
+class EmbeddingConfig:
+    """Embedding configuration structure."""
+
+    model: Optional[str]
+    """The embedding model name."""
+
+    dimensions: Optional[int]
+    """The dimensions of the embedding."""
+
+    timeout: Optional[int]
+    """The timeout of the embedding model in seconds."""
+
+    max_sequence_length: Optional[int]
+    """The maximum sequence length of the embedding model."""
+
+    caching: Optional[bool]
+    """Whether to cache the embedding."""
+
+    api_endpoint: Optional[str]
+    """The API endpoint URL."""
+
+    api_key: Optional[SecretStr]
+    """The API key."""
+
+
+class RagConfig:
+    """RAG (Retrieval Augmented Generation) configuration structure."""
+
+    milvus_uri: Optional[str]
+    """The URI of the Milvus server."""
+
+    milvus_timeout: Optional[float]
+    """The timeout of the Milvus server in seconds."""
+
+    milvus_token: Optional[SecretStr]
+    """The token for Milvus authentication."""
+
+    milvus_dimensions: Optional[int]
+    """The dimensions for Milvus vectors."""
+
+
+class DebugConfig:
+    """Debug configuration structure."""
+
+    log_level: Optional[str]
+    """The logging level to use."""
+
+
+class TemplateManagerConfig:
+    """Template manager configuration structure."""
+
+    template_dir: List[str]
+    """The directories containing the templates."""
+
+    active_loading: Optional[bool]
+    """Whether to enable active loading of templates."""
+
+    template_suffix: Optional[str]
+    """The suffix of the templates."""
+
+
+class TemplateConfig:
+    """Template configuration structure."""
+
+    create_json_obj_template: str
+    """The name of the create json object template which will be used to create a json object."""
+
+    draft_tool_usage_code_template: str
+    """The name of the draft tool usage code template which will be used to draft tool usage code."""
+
+    make_choice_template: str
+    """The name of the make choice template which will be used to make a choice."""
+
+    make_judgment_template: str
+    """The name of the make judgment template which will be used to make a judgment."""
+
+    dependencies_template: str
+    """The name of the dependencies template which will be used to manage dependencies."""
+
+    task_briefing_template: str
+    """The name of the task briefing template which will be used to brief a task."""
+
+    rate_fine_grind_template: str
+    """The name of the rate fine grind template which will be used to rate fine grind."""
+
+    draft_rating_manual_template: str
+    """The name of the draft rating manual template which will be used to draft rating manual."""
+
+    draft_rating_criteria_template: str
+    """The name of the draft rating criteria template which will be used to draft rating criteria."""
+
+    extract_reasons_from_examples_template: str
+    """The name of the extract reasons from examples template which will be used to extract reasons from examples."""
+
+    extract_criteria_from_reasons_template: str
+    """The name of the extract criteria from reasons template which will be used to extract criteria from reasons."""
+
+    draft_rating_weights_klee_template: str
+    """The name of the draft rating weights klee template which will be used to draft rating weights with Klee method."""
+
+    retrieved_display_template: str
+    """The name of the retrieved display template which will be used to display retrieved documents."""
+
+    liststr_template: str
+    """The name of the liststr template which will be used to display a list of strings."""
+
+    refined_query_template: str
+    """The name of the refined query template which will be used to refine a query."""
+
+    pathstr_template: str
+    """The name of the pathstr template which will be used to acquire a path of strings."""
+
+    review_string_template: str
+    """The name of the review string template which will be used to review a string."""
+
+    generic_string_template: str
+    """The name of the generic string template which will be used to review a string."""
+
+    co_validation_template: str
+    """The name of the co-validation template which will be used to co-validate a string."""
+
+    as_prompt_template: str
+    """The name of the as prompt template which will be used to convert a string to a prompt."""
+
+    check_string_template: str
+    """The name of the check string template which will be used to check a string."""
+
+    ruleset_requirement_breakdown_template: str
+    """The name of the ruleset requirement breakdown template which will be used to breakdown a ruleset requirement."""
+
+    fix_troubled_obj_template: str
+    """The name of the fix troubled object template which will be used to fix a troubled object."""
+
+    fix_troubled_string_template: str
+    """The name of the fix troubled string template which will be used to fix a troubled string."""
+
+    rule_requirement_template: str
+    """The name of the rule requirement template which will be used to generate a rule requirement."""
+
+    extract_template: str
+    """The name of the extract template which will be used to extract model from string."""
+
+    chap_summary_template: str
+    """The name of the chap summary template which will be used to generate a chapter summary."""
+
+
+class RoutingConfig:
+    """Routing configuration structure for controlling request dispatching behavior."""
+
+    max_parallel_requests: Optional[int]
+    """The maximum number of parallel requests. None means not checked."""
+
+    allowed_fails: Optional[int]
+    """The number of allowed fails before the routing is considered failed."""
+
+    retry_after: int
+    """Minimum time to wait before retrying a failed request."""
+
+    cooldown_time: Optional[int]
+    """Time to cooldown a deployment after failure in seconds."""
+
+
+class GeneralConfig:
+    """General configuration structure for application-wide settings."""
+
+    confirm_on_ops: bool
+    """Whether to confirm operations before executing them."""
+
+    use_json_repair: bool
+    """Whether to automatically repair malformed JSON."""
+
+
+class ToolBoxConfig:
+    """Configuration for toolbox functionality."""
+
+    tool_module_name: str
+    """The name of the module containing the toolbox."""
+
+    data_module_name: str
+    """The name of the module containing the data."""
+
+
+class PymitterConfig:
+    """Pymitter configuration structure for controlling event emission and listener behavior."""
+
+    delimiter: str
+    """The delimiter used to separate the event name into segments."""
+
+    new_listener_event: bool
+    """If set, a newListener event is emitted when a new listener is added."""
+
+    max_listeners: int
+    """The maximum number of listeners per event. -1 means unlimited."""
+
+
+class Config:
+    """Configuration structure containing all system components."""
+
+    embedding: EmbeddingConfig
+    """Embedding configuration."""
+
+    llm: LLMConfig
+    """LLM configuration."""
+
+    debug: DebugConfig
+    """Debug configuration."""
+
+    rag: RagConfig
+    """RAG configuration."""
+
+    templates: TemplateConfig
+    """Template configuration."""
+
+    template_manager: TemplateManagerConfig
+    """Template manager configuration."""
+
+    routing: RoutingConfig
+    """Routing configuration."""
+
+    general: GeneralConfig
+    """General configuration."""
+
+    toolbox: ToolBoxConfig
+    """Toolbox configuration."""
+
+    pymitter: PymitterConfig
+    """Pymitter configuration."""
+
+
+CONFIG: Config
+
+
+class SecretStr:
+    """A string that should not be exposed."""
+
+    def __init__(self, source: str) -> None: ...
+
+    def expose(self) -> str:
+        """Expose the secret string."""
+
+
+TEMPLATE_MANAGER: TemplateManager
+
+
+class Event:
+    """Event class that represents a hierarchical event with segments.
+
+    Events can be constructed from strings, lists of strings, or other Events.
+    """
+    segments: List[str]
+
+    def __init__(self, segments: Optional[List[str]] = None) -> None:
+        """Initialize a new Event with optional segments.
+
+        Args:
+            segments: Optional list of string segments
+        """
+
+    @staticmethod
+    def instantiate_from(event: Union[str, Event, List[str]]) -> Event:
+        """Create an Event from a string, list of strings, or another Event.
+
+        Args:
+            event: The source to create the Event from
+
+        Returns:
+            A new Event instance
+
+        Raises:
+            ValueError: If list elements are not strings
+            TypeError: If event is an invalid type
+        """
+
+    @staticmethod
+    def quick_instantiate(event: Union[str, Event, List[str]]) -> Event:
+        """Create an Event and append wildcard and pending status.
+
+        Args:
+            event: The source to create the Event from
+
+        Returns:
+            A new Event instance with wildcard and pending status appended
+        """
+
+    def derive(self, event: Union[str, Event, List[str]]) -> Event:
+        """Create a new Event by extending this one with another.
+
+        Args:
+            event: The Event to append
+
+        Returns:
+            A new Event that combines this Event with the provided one
+        """
+
+    def collapse(self) -> str:
+        """Convert the Event to a delimited string.
+
+        Returns:
+            String representation with segments joined by delimiter
+        """
+
+    def fork(self) -> Event:
+        """Create a copy of this Event.
+
+        Returns:
+            A new Event with the same segments
+        """
+
+    def push(self, segment: str) -> Self:
+        """Add a segment to the Event.
+
+        Args:
+            segment: String segment to add
+
+        Raises:
+            ValueError: If segment is empty or contains the delimiter
+        """
+
+    def push_wildcard(self) -> Self:
+        """Add a wildcard segment (*) to the Event."""
+
+    def push_pending(self) -> Self:
+        """Add a pending status segment to the Event."""
+
+    def push_running(self) -> Self:
+        """Add a running status segment to the Event."""
+
+    def push_finished(self) -> Self:
+        """Add a finished status segment to the Event."""
+
+    def push_failed(self) -> Self:
+        """Add a failed status segment to the Event."""
+
+    def push_cancelled(self) -> Self:
+        """Add a cancelled status segment to the Event."""
+
+    def pop(self) -> Optional[str]:
+        """Remove and return the last segment.
+
+        Returns:
+            The removed segment or None if the Event is empty
+        """
+
+    def clear(self) -> Self:
+        """Remove all segments from the Event."""
+
+    def concat(self, event: Union[str, Event, List[str]]) -> Self:
+        """Append segments from another Event to this one.
+
+        Args:
+            event: The Event to append segments from
+        """
+
+    def __hash__(self) -> int: ...
+
+    def __eq__(self, other: object) -> bool: ...
+
+    def __ne__(self, other: object) -> bool: ...
+
+
+class TaskStatus(StrEnum, str):
+    """Enumeration of possible task statuses."""
+
+    Pending: TaskStatus
+    """Task is pending execution."""
+
+    Running: TaskStatus
+    """Task is currently running."""
+
+    Finished: TaskStatus
+    """Task has finished successfully."""
+
+    Failed: TaskStatus
+    """Task has failed."""
+
+    Cancelled: TaskStatus
+    """Task has been cancelled."""

fabricatio/utils.py

@@ -1,15 +1,46 @@
 """A collection of utility functions for the fabricatio package."""
 
-from typing import Any, Dict, List, Mapping, Optional, TypedDict, Unpack, overload
-
-import aiohttp
-import requests
+from typing import Any, Dict, List, Mapping, Optional, TypedDict, Unpack, overload, Type, Tuple
 
 from fabricatio.decorators import precheck_package
 from fabricatio.journal import logger
 from fabricatio.models.kwargs_types import RerankOptions
 
 
+def is_subclass_of_base(cls: Type, base_module: str, base_name: str) -> bool:
+    """Determines if the given class is a subclass of an unimported base class.
+    
+    Args:
+        cls: The class to check
+        base_module: The module name of the base class
+        base_name: The class name of the base class
+        
+    Returns:
+        bool: True if cls is a subclass of the specified base class, False otherwise
+    """
+    for ancestor in cls.__mro__:
+        if ancestor.__module__ == base_module and ancestor.__name__ == base_name:
+            return True
+    return False
+
+
+def is_subclass_of_any_base(cls: Type, bases: List[Tuple[str, str]]) -> bool:
+    """Determines if the given class is a subclass of the candidate base classes.
+    
+    Args:
+        cls: The class to check
+        bases: A list of tuples where each tuple contains (module_name, class_name)
+        
+    Returns:
+        bool: True if cls is a subclass of the specified base classes, False otherwise
+    """
+    for ancestor in cls.__mro__:
+        for base_module, base_name in bases:
+            if ancestor.__module__ == base_module and ancestor.__name__ == base_name:
+                return True
+    return False
+
+
 @precheck_package(
     "questionary", "'questionary' is required to run this function. Have you installed `fabricatio[qa]`?."
 )
@@ -164,6 +195,7 @@ class RerankerAPI:
             ValueError: If input parameters are invalid or the API returns a client-side error.
             RuntimeError: If the API call fails or returns a server-side error.
         """
+        import requests
         # Validate inputs
         if not isinstance(query, str) or not query.strip():
             raise ValueError("Query must be a non-empty string.")
@@ -219,6 +251,8 @@ class RerankerAPI:
             ValueError: If input parameters are invalid or the API returns a client-side error.
             RuntimeError: If the API call fails or returns a server-side error.
         """
+        import aiohttp
+
         # Validate inputs
         if not isinstance(query, str) or not query.strip():
             raise ValueError("Query must be a non-empty string.")

{fabricatio-0.2.13.dev3.dist-info → fabricatio-0.3.14.dev0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fabricatio
-Version: 0.2.13.dev3
+Version: 0.3.14.dev0
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: 3.12
@@ -8,7 +8,6 @@ Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Framework :: AsyncIO
 Classifier: Framework :: Pydantic :: 2
 Classifier: Typing :: Typed
-Requires-Dist: appdirs>=1.4.4
 Requires-Dist: asyncio>=3.4.3
 Requires-Dist: asyncstdlib>=3.13.0
 Requires-Dist: json-repair>=0.39.1
@@ -16,7 +15,6 @@ Requires-Dist: litellm>=1.60.0
 Requires-Dist: loguru>=0.7.3
 Requires-Dist: more-itertools>=10.6.0
 Requires-Dist: pydantic>=2.10.6
-Requires-Dist: pydantic-settings>=2.7.1
 Requires-Dist: pymitter>=1.0.0
 Requires-Dist: rich>=13.9.4
 Requires-Dist: ujson>=5.10.0

fabricatio-0.3.14.dev0.dist-info/RECORD

@@ -0,0 +1,63 @@
+fabricatio-0.3.14.dev0.dist-info/METADATA,sha256=wYdyUN-54xDS1x4TkCPzO8tQ8XZKmMOz5O33vlSWGSg,5246
+fabricatio-0.3.14.dev0.dist-info/WHEEL,sha256=jABKVkLC9kJr8mi_er5jOqpiQUjARSLXDUIIxDqsS50,96
+fabricatio-0.3.14.dev0.dist-info/licenses/LICENSE,sha256=do7J7EiCGbq0QPbMAL_FqLYufXpHnCnXBOuqVPwSV8Y,1088
+fabricatio/actions/article.py,sha256=vkYbzRy4SSJL73SFdgdsMfUy3nbjNFc44mu1-uPjqBo,12627
+fabricatio/actions/article_rag.py,sha256=Ahij8TSNvE5T1rHhJM5zNj57SaORldNj1YEHFTj0xm8,18631
+fabricatio/actions/fs.py,sha256=gJR14U4ln35nt8Z7OWLVAZpqGaLnED-r1Yi-lX22tkI,959
+fabricatio/actions/output.py,sha256=w_7xVFs7OZ8uXqFQKmuXw7Y0vWugSuN6phcVW_VnCqI,8389
+fabricatio/actions/rag.py,sha256=UifqC4jPpmhTrfToXkqi6ElbNxUoc2wqSMJQEubkhNU,3589
+fabricatio/actions/rules.py,sha256=dkvCgNDjt2KSO1VgPRsxT4YBmIIMeetZb5tiz-slYkU,3640
+fabricatio/actions/__init__.py,sha256=wVENCFtpVb1rLFxoOFJt9-8smLWXuJV7IwA8P3EfFz4,48
+fabricatio/capabilities/advanced_judge.py,sha256=selB0Gwf1F4gGJlwBiRo6gI4KOUROgh3WnzO3mZFEls,706
+fabricatio/capabilities/advanced_rag.py,sha256=FaXHGOqS4VleGSLsnC5qm4S4EBcHZLZbj8TjXRieKBs,2513
+fabricatio/capabilities/censor.py,sha256=bBT5qy-kp7fh8g4Lz3labSwxwJ60gGd_vrkc6k1cZ1U,4719
+fabricatio/capabilities/check.py,sha256=3Y7M9DLYWJefCMDg4aSYuU7XgVdWGR4ElQVeHFVYt4U,8663
+fabricatio/capabilities/correct.py,sha256=K-m8OZK25AjboGQXFltNk_A3WPBByi1sG_fuEHWDGFw,10445
+fabricatio/capabilities/extract.py,sha256=005FFcLAC_A6FNmuGK679yJtTL8ai__Zg5bjG9eiSts,2619
+fabricatio/capabilities/propose.py,sha256=hkBeSlmcTdfYWT-ph6nlbtHXBozi_JXqXlWcnBy3W78,2007
+fabricatio/capabilities/rag.py,sha256=LHSpBW6FTEgUvsIbE5HGhlRba_bRV5-kM1s8fZUc_IM,11143
+fabricatio/capabilities/rating.py,sha256=JdxNzjg7hQO6Cbe4Muf20r6f1Cb9dQnUBQq1VRS_bRU,18089
+fabricatio/capabilities/review.py,sha256=qimV-r51nqLtAcKBO0SKS_J06DYLUL-FsbZNA9JxQ9k,5060
+fabricatio/capabilities/task.py,sha256=mqRzrNBJEYTYbNfDPhTNy9bpDFyUpygff6FKBiNumbA,4431
+fabricatio/capabilities/__init__.py,sha256=v1cHRHIJ2gxyqMLNCs6ERVcCakSasZNYzmMI4lqAcls,57
+fabricatio/core.py,sha256=KN2Rx-j46xzCh9s2ckfXruz3lui6Q2JPV6LKwjHhkJQ,6485
+fabricatio/decorators.py,sha256=TGUTUuIfSV2u6Thv1kmAVXAPN_8ynP5T28R8MQw8eg0,8990
+fabricatio/fs/curd.py,sha256=652nHulbJ3gwt0Z3nywtPMmjhEyglDvEfc3p7ieJNNA,4777
+fabricatio/fs/readers.py,sha256=UXvcJO3UCsxHu9PPkg34Yh55Zi-miv61jD_wZQJgKRs,1751
+fabricatio/fs/__init__.py,sha256=USoMI_HcIr3Yc77_JQYYsXrsplYPXtFTaNB9YgFfC4s,713
+fabricatio/journal.py,sha256=I02_ntN7_WyI_m1RsHB1gEv8LfWtcVGmOqppEV8XjKI,289
+fabricatio/models/action.py,sha256=-XIzuE-LE38GWuj_0WdSGSQ7kVUMzXUUnfqJ-XcA20o,10084
+fabricatio/models/adv_kwargs_types.py,sha256=IBV3ZcsNLvvEjO_2hBpYg_wLSpNKaMx6Ndam3qXJCw8,2097
+fabricatio/models/extra/advanced_judge.py,sha256=INUl_41C8jkausDekkjnEmTwNfLCJ23TwFjq2cM23Cw,1092
+fabricatio/models/extra/aricle_rag.py,sha256=2dHQOz7Br8xpf3PTtdZmrIw49kC4_YGa89evta67LYg,11707
+fabricatio/models/extra/article_base.py,sha256=4veM9DNd7T54iocoLS1mP-jOPImrxACAzfsdd6A3LIU,16736
+fabricatio/models/extra/article_essence.py,sha256=mlIkkRMR3I1RtqiiOnmIE3Vy623L4eECumkRzryE1pw,2749
+fabricatio/models/extra/article_main.py,sha256=jOHJt6slBakOAdY8IDq4JPiPGXX0_g1n3ROm802UYqc,11221
+fabricatio/models/extra/article_outline.py,sha256=mw7eOuKMJgns4bihjcjOEIpAy38i0g-x6T6Vx3J0T5A,1629
+fabricatio/models/extra/article_proposal.py,sha256=NbyjW-7UiFPtnVD9nte75re4xL2pD4qL29PpNV4Cg_M,1870
+fabricatio/models/extra/patches.py,sha256=_WNCxtYzzsVfUxI16vu4IqsLahLYRHdbQN9er9tqhC0,997
+fabricatio/models/extra/problem.py,sha256=8tTU-3giFHOi5j7NJsvH__JJyYcaGrcfsRnkzQNm0Ew,7216
+fabricatio/models/extra/rag.py,sha256=RMi8vhEPB0I5mVmjRLRLxYHUnm9pFhvVwysaIwmW2s0,3955
+fabricatio/models/extra/rule.py,sha256=KQQELVhCLUXhEZ35jU3WGYqKHuCYEAkn0p6pxAE-hOU,2625
+fabricatio/models/extra/__init__.py,sha256=XlYnS_2B9nhLhtQkjE7rvvfPmAAtXVdNi9bSDAR-Ge8,54
+fabricatio/models/generic.py,sha256=c-_VogsBUbNaU11KZizCI4AzLgg5_FCRLbNYcQKHyks,30424
+fabricatio/models/kwargs_types.py,sha256=tDeF0B_TnumYGCKU58f-llAApn6ng_Joz8CcGq5GiLk,3619
+fabricatio/models/role.py,sha256=Uukgh3Nxk5N2QEnyg9CMfsngW9GSgKV_Z7nnvafUYfc,3810
+fabricatio/models/task.py,sha256=vOL8mzwBRMWC8R_59zh4SDXkjWuAL6WTtsAGfcxp_eE,11032
+fabricatio/models/tool.py,sha256=uNYVCNr9KUBWQ_KAtekGECdNPZREGJ9Aioyk4lrvtTE,12503
+fabricatio/models/usages.py,sha256=FyWdKAce2Am10zByISBuf_Tdd4hRnhkAxcXIzyV77LU,33474
+fabricatio/parser.py,sha256=QXHoJf0i9lAuaUjPBltXXvDZqyeuPwDLdQgr1uMU95w,6633
+fabricatio/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fabricatio/rust.pyi,sha256=fWK5q3b-TEDfSYQh9vlZq-kTpA9NBXttGszPMVEnODs,25221
+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=_kNYzLzBudhjZ3RwgeIPKSxKbOVMgCwoj-BzjYPB0G8,11566
+fabricatio/workflows/articles.py,sha256=ObYTFUqLUk_CzdmmnX6S7APfxcGmPFqnFr9pdjU7Z4Y,969
+fabricatio/workflows/rag.py,sha256=-YYp2tlE9Vtfgpg6ROpu6QVO8j8yVSPa6yDzlN3qVxs,520
+fabricatio/workflows/__init__.py,sha256=5ScFSTA-bvhCesj3U9Mnmi6Law6N1fmh5UKyh58L3u8,51
+fabricatio/__init__.py,sha256=QoZ1WNvK5UVaMGed2GOE781TvF76om3LHe5eVEBSSUE,809
+fabricatio/rust.cp312-win_amd64.pyd,sha256=lvRcjPuXO8XglnZ9J7QX4AJx1z7Zfj13Msia4orfs-A,6022144
+fabricatio-0.3.14.dev0.data/scripts/tdown.exe,sha256=dNcSMR1zfpD8t_QYEP0xfqCfEZZ1P1EBWYOxroxTWSU,3356160
+fabricatio-0.3.14.dev0.data/scripts/ttm.exe,sha256=Q4kRd27t8Fv--kYuoHqhK0NyvFt2jCY8Q11vrWDa2z0,2554880
+fabricatio-0.3.14.dev0.dist-info/RECORD,,