fabricatio 0.2.13.dev2__cp312-cp312-win_amd64.whl → 0.3.13__cp312-cp312-win_amd64.whl

fabricatio/capabilities/rating.py

@@ -4,16 +4,15 @@ from itertools import permutations
 from random import sample
 from typing import Dict, List, Optional, Set, Tuple, Union, Unpack, overload
 
+from fabricatio.rust import CONFIG, TEMPLATE_MANAGER
 from more_itertools import flatten, windowed
 from pydantic import Field, NonNegativeInt, PositiveInt, create_model
 
 from fabricatio.capabilities.propose import Propose
-from fabricatio.config import configs
 from fabricatio.journal import logger
 from fabricatio.models.generic import Display, ProposedAble
 from fabricatio.models.kwargs_types import CompositeScoreKwargs, ValidateKwargs
 from fabricatio.parser import JsonCapture
-from fabricatio.rust_instances import TEMPLATE_MANAGER
 from fabricatio.utils import ok, override_kwargs
 
 
@@ -25,11 +24,11 @@ class Rating(Propose):
     """
 
     async def rate_fine_grind(
-        self,
-        to_rate: str | List[str],
-        rating_manual: Dict[str, str],
-        score_range: Tuple[float, float],
-        **kwargs: Unpack[ValidateKwargs[Dict[str, float]]],
+            self,
+            to_rate: str | List[str],
+            rating_manual: Dict[str, str],
+            score_range: Tuple[float, float],
+            **kwargs: Unpack[ValidateKwargs[Dict[str, float]]],
     ) -> Dict[str, float] | List[Dict[str, float]] | List[Optional[Dict[str, float]]] | None:
         """Rate a given string based on a rating manual and score range.
 
@@ -66,13 +65,13 @@ class Rating(Propose):
         res = await self.propose(
             model,
             TEMPLATE_MANAGER.render_template(
-                configs.templates.rate_fine_grind_template,
+                CONFIG.templates.rate_fine_grind_template,
                 {"to_rate": to_rate, "min_score": min_score, "max_score": max_score},
             )
             if isinstance(to_rate, str)
             else [
                 TEMPLATE_MANAGER.render_template(
-                    configs.templates.rate_fine_grind_template,
+                    CONFIG.templates.rate_fine_grind_template,
                     {"to_rate": t, "min_score": min_score, "max_score": max_score},
                 )
                 for t in to_rate
@@ -88,34 +87,36 @@ class Rating(Propose):
 
     @overload
     async def rate(
-        self,
-        to_rate: str,
-        topic: str,
-        criteria: Set[str],
-        manual: Optional[Dict[str, str]] = None,
-        score_range: Tuple[float, float] = (0.0, 1.0),
-        **kwargs: Unpack[ValidateKwargs],
-    ) -> Dict[str, float]: ...
+            self,
+            to_rate: str,
+            topic: str,
+            criteria: Set[str],
+            manual: Optional[Dict[str, str]] = None,
+            score_range: Tuple[float, float] = (0.0, 1.0),
+            **kwargs: Unpack[ValidateKwargs],
+    ) -> Dict[str, float]:
+        ...
 
     @overload
     async def rate(
-        self,
-        to_rate: List[str],
-        topic: str,
-        criteria: Set[str],
-        manual: Optional[Dict[str, str]] = None,
-        score_range: Tuple[float, float] = (0.0, 1.0),
-        **kwargs: Unpack[ValidateKwargs],
-    ) -> List[Dict[str, float]]: ...
+            self,
+            to_rate: List[str],
+            topic: str,
+            criteria: Set[str],
+            manual: Optional[Dict[str, str]] = None,
+            score_range: Tuple[float, float] = (0.0, 1.0),
+            **kwargs: Unpack[ValidateKwargs],
+    ) -> List[Dict[str, float]]:
+        ...
 
     async def rate(
-        self,
-        to_rate: Union[str, List[str]],
-        topic: str,
-        criteria: Set[str],
-        manual: Optional[Dict[str, str]] = None,
-        score_range: Tuple[float, float] = (0.0, 1.0),
-        **kwargs: Unpack[ValidateKwargs],
+            self,
+            to_rate: Union[str, List[str]],
+            topic: str,
+            criteria: Set[str],
+            manual: Optional[Dict[str, str]] = None,
+            score_range: Tuple[float, float] = (0.0, 1.0),
+            **kwargs: Unpack[ValidateKwargs],
     ) -> Dict[str, float] | List[Dict[str, float]] | List[Optional[Dict[str, float]]] | None:
         """Rate a given string or a sequence of strings based on a topic, criteria, and score range.
 
@@ -132,15 +133,15 @@ class Rating(Propose):
             or a list of dictionaries with the ratings for each criterion if a sequence of strings is provided.
         """
         manual = (
-            manual
-            or await self.draft_rating_manual(topic, criteria, **override_kwargs(kwargs, default=None))
-            or dict(zip(criteria, criteria, strict=True))
+                manual
+                or await self.draft_rating_manual(topic, criteria, **override_kwargs(kwargs, default=None))
+                or dict(zip(criteria, criteria, strict=True))
         )
 
         return await self.rate_fine_grind(to_rate, manual, score_range, **kwargs)
 
     async def draft_rating_manual(
-        self, topic: str, criteria: Optional[Set[str]] = None, **kwargs: Unpack[ValidateKwargs[Dict[str, str]]]
+            self, topic: str, criteria: Optional[Set[str]] = None, **kwargs: Unpack[ValidateKwargs[Dict[str, str]]]
     ) -> Optional[Dict[str, str]]:
         """Drafts a rating manual based on a topic and dimensions.
 
@@ -155,9 +156,9 @@ class Rating(Propose):
 
         def _validator(response: str) -> Dict[str, str] | None:
             if (
-                (json_data := JsonCapture.validate_with(response, target_type=dict, elements_type=str)) is not None
-                and json_data.keys() == criteria
-                and all(isinstance(v, str) for v in json_data.values())
+                    (json_data := JsonCapture.validate_with(response, target_type=dict, elements_type=str)) is not None
+                    and json_data.keys() == criteria
+                    and all(isinstance(v, str) for v in json_data.values())
             ):
                 return json_data
             return None
@@ -171,7 +172,7 @@ class Rating(Propose):
         return await self.aask_validate(
             question=(
                 TEMPLATE_MANAGER.render_template(
-                    configs.templates.draft_rating_manual_template,
+                    CONFIG.templates.draft_rating_manual_template,
                     {
                         "topic": topic,
                         "criteria": list(criteria),
@@ -183,10 +184,10 @@ class Rating(Propose):
         )
 
     async def draft_rating_criteria(
-        self,
-        topic: str,
-        criteria_count: NonNegativeInt = 0,
-        **kwargs: Unpack[ValidateKwargs[Set[str]]],
+            self,
+            topic: str,
+            criteria_count: NonNegativeInt = 0,
+            **kwargs: Unpack[ValidateKwargs[Set[str]]],
     ) -> Optional[Set[str]]:
         """Drafts rating dimensions based on a topic.
 
@@ -201,7 +202,7 @@ class Rating(Propose):
         return await self.aask_validate(
             question=(
                 TEMPLATE_MANAGER.render_template(
-                    configs.templates.draft_rating_criteria_template,
+                    CONFIG.templates.draft_rating_criteria_template,
                     {
                         "topic": topic,
                         "criteria_count": criteria_count,
@@ -215,13 +216,13 @@ class Rating(Propose):
         )
 
     async def draft_rating_criteria_from_examples(
-        self,
-        topic: str,
-        examples: List[str],
-        m: NonNegativeInt = 0,
-        reasons_count: PositiveInt = 2,
-        criteria_count: PositiveInt = 5,
-        **kwargs: Unpack[ValidateKwargs],
+            self,
+            topic: str,
+            examples: List[str],
+            m: NonNegativeInt = 0,
+            reasons_count: PositiveInt = 2,
+            criteria_count: PositiveInt = 5,
+            **kwargs: Unpack[ValidateKwargs],
     ) -> Optional[Set[str]]:
         """Asynchronously drafts a set of rating criteria based on provided examples.
 
@@ -251,7 +252,7 @@ class Rating(Propose):
             await self.aask_validate(  # pyright: ignore [reportArgumentType]
                 question=[
                     TEMPLATE_MANAGER.render_template(
-                        configs.templates.extract_reasons_from_examples_template,
+                        CONFIG.templates.extract_reasons_from_examples_template,
                         {
                             "topic": topic,
                             "first": pair[0],
@@ -271,7 +272,7 @@ class Rating(Propose):
         return await self.aask_validate(
             question=(
                 TEMPLATE_MANAGER.render_template(
-                    configs.templates.extract_criteria_from_reasons_template,
+                    CONFIG.templates.extract_criteria_from_reasons_template,
                     {
                         "topic": topic,
                         "reasons": list(reasons),
@@ -286,10 +287,10 @@ class Rating(Propose):
         )
 
     async def drafting_rating_weights_klee(
-        self,
-        topic: str,
-        criteria: Set[str],
-        **kwargs: Unpack[ValidateKwargs[float]],
+            self,
+            topic: str,
+            criteria: Set[str],
+            **kwargs: Unpack[ValidateKwargs[float]],
     ) -> Dict[str, float]:
         """Drafts rating weights for a given topic and criteria using the Klee method.
 
@@ -311,7 +312,7 @@ class Rating(Propose):
         relative_weights = await self.aask_validate(
             question=[
                 TEMPLATE_MANAGER.render_template(
-                    configs.templates.draft_rating_weights_klee_template,
+                    CONFIG.templates.draft_rating_weights_klee_template,
                     {
                         "topic": topic,
                         "first": pair[0],
@@ -332,14 +333,14 @@ class Rating(Propose):
         return dict(zip(criteria_seq, [w / total for w in weights], strict=True))
 
     async def composite_score(
-        self,
-        topic: str,
-        to_rate: List[str],
-        criteria: Optional[Set[str]] = None,
-        weights: Optional[Dict[str, float]] = None,
-        manual: Optional[Dict[str, str]] = None,
-        approx: bool = False,
-        **kwargs: Unpack[ValidateKwargs[List[Dict[str, float]]]],
+            self,
+            topic: str,
+            to_rate: List[str],
+            criteria: Optional[Set[str]] = None,
+            weights: Optional[Dict[str, float]] = None,
+            manual: Optional[Dict[str, str]] = None,
+            approx: bool = False,
+            **kwargs: Unpack[ValidateKwargs[List[Dict[str, float]]]],
     ) -> List[float]:
         """Calculates the composite scores for a list of items based on a given topic and criteria.
 
@@ -369,14 +370,17 @@ class Rating(Propose):
         return [sum(ratings[c] * weights[c] for c in criteria) for ratings in ratings_seq]
 
     @overload
-    async def best(self, candidates: List[str], k: int = 1, **kwargs: Unpack[CompositeScoreKwargs]) -> List[str]: ...
+    async def best(self, candidates: List[str], k: int = 1, **kwargs: Unpack[CompositeScoreKwargs]) -> List[str]:
+        ...
+
     @overload
     async def best[T: Display](
-        self, candidates: List[T], k: int = 1, **kwargs: Unpack[CompositeScoreKwargs]
-    ) -> List[T]: ...
+            self, candidates: List[T], k: int = 1, **kwargs: Unpack[CompositeScoreKwargs]
+    ) -> List[T]:
+        ...
 
     async def best[T: Display](
-        self, candidates: List[str] | List[T], k: int = 1, **kwargs: Unpack[CompositeScoreKwargs]
+            self, candidates: List[str] | List[T], k: int = 1, **kwargs: Unpack[CompositeScoreKwargs]
     ) -> Optional[List[str] | List[T]]:
         """Choose the best candidates from the list of candidates based on the composite score.
 
@@ -400,4 +404,5 @@ class Rating(Propose):
         rating_seq = await self.composite_score(
             to_rate=[c.display() if isinstance(c, Display) else c for c in candidates], **kwargs
         )
-        return [a[0] for a in sorted(zip(candidates, rating_seq, strict=True), key=lambda x: x[1], reverse=True)[:k]]  # pyright: ignore [reportReturnType]
+        return [a[0] for a in sorted(zip(candidates, rating_seq, strict=True), key=lambda x: x[1], reverse=True)[
+                              :k]]  # pyright: ignore [reportReturnType]

fabricatio/capabilities/review.py

@@ -2,14 +2,14 @@
 
 from typing import Dict, Optional, Set, Unpack
 
+from fabricatio.rust import CONFIG, TEMPLATE_MANAGER
+
 from fabricatio.capabilities.propose import Propose
 from fabricatio.capabilities.rating import Rating
-from fabricatio.config import configs
 from fabricatio.models.extra.problem import Improvement
 from fabricatio.models.generic import Display, WithBriefing
 from fabricatio.models.kwargs_types import ReviewKwargs, ValidateKwargs
 from fabricatio.models.task import Task
-from fabricatio.rust_instances import TEMPLATE_MANAGER
 from fabricatio.utils import ok
 
 
@@ -41,12 +41,12 @@ class Review(Rating, Propose):
         return await self.review_obj(task, **kwargs)
 
     async def review_string(
-        self,
-        input_text: str,
-        topic: str,
-        criteria: Optional[Set[str]] = None,
-        rating_manual: Optional[Dict[str, str]] = None,
-        **kwargs: Unpack[ValidateKwargs[Improvement]],
+            self,
+            input_text: str,
+            topic: str,
+            criteria: Optional[Set[str]] = None,
+            rating_manual: Optional[Dict[str, str]] = None,
+            **kwargs: Unpack[ValidateKwargs[Improvement]],
     ) -> Optional[Improvement]:
         """Review a string based on specified topic and criteria.
 
@@ -70,7 +70,7 @@ class Review(Rating, Propose):
             # this `default` is the default for the `propose` method
             default = kwargs.pop("default")
 
-        criteria = ok(criteria or (await self.draft_rating_criteria(topic, **kwargs))," No criteria could be use.")
+        criteria = ok(criteria or (await self.draft_rating_criteria(topic, **kwargs)), " No criteria could be use.")
         manual = rating_manual or await self.draft_rating_manual(topic, criteria, **kwargs)
 
         if default is not None:
@@ -78,13 +78,14 @@ class Review(Rating, Propose):
         return await self.propose(
             Improvement,
             TEMPLATE_MANAGER.render_template(
-                configs.templates.review_string_template,
+                CONFIG.templates.review_string_template,
                 {"text": input_text, "topic": topic, "criteria_manual": manual},
             ),
             **kwargs,
         )
 
-    async def review_obj[M: (Display, WithBriefing)](self, obj: M, **kwargs: Unpack[ReviewKwargs[Improvement]]) -> Optional[Improvement]:
+    async def review_obj[M: (Display, WithBriefing)](self, obj: M, **kwargs: Unpack[ReviewKwargs[Improvement]]) -> \
+            Optional[Improvement]:
         """Review an object that implements Display or WithBriefing interface.
 
         This method extracts displayable text from the object and performs a review

fabricatio/capabilities/task.py

@@ -4,16 +4,15 @@ from types import CodeType
 from typing import Any, Dict, List, Optional, Tuple, Unpack
 
 import ujson
+from fabricatio.rust import CONFIG, TEMPLATE_MANAGER
 
 from fabricatio.capabilities.propose import Propose
-from fabricatio.config import configs
 from fabricatio.journal import logger
 from fabricatio.models.kwargs_types import ChooseKwargs, ValidateKwargs
 from fabricatio.models.task import Task
 from fabricatio.models.tool import Tool, ToolExecutor
 from fabricatio.models.usages import ToolBoxUsage
 from fabricatio.parser import JsonCapture, PythonCapture
-from fabricatio.rust_instances import TEMPLATE_MANAGER
 
 
 class ProposeTask(Propose):
@@ -67,10 +66,10 @@ class HandleTask(ToolBoxUsage):
             return None
 
         q = TEMPLATE_MANAGER.render_template(
-            configs.templates.draft_tool_usage_code_template,
+            CONFIG.templates.draft_tool_usage_code_template,
             {
-                "data_module_name": configs.toolbox.data_module_name,
-                "tool_module_name": configs.toolbox.tool_module_name,
+                "data_module_name": CONFIG.toolbox.data_module_name,
+                "tool_module_name": CONFIG.toolbox.tool_module_name,
                 "task": task.briefing,
                 "deps": task.dependencies_prompt,
                 "tools": [{"name": t.name, "briefing": t.briefing} for t in tools],

fabricatio/core.py

@@ -2,12 +2,10 @@
 
 from typing import Callable, Optional, Self, overload
 
+from fabricatio.rust import CONFIG, Event
 from pydantic import BaseModel, ConfigDict, PrivateAttr
 from pymitter import EventEmitter
 
-from fabricatio.config import configs
-from fabricatio.models.events import Event
-
 
 class Env(BaseModel):
     """Environment class that manages event handling using EventEmitter."""
@@ -15,9 +13,9 @@ class Env(BaseModel):
     model_config = ConfigDict(use_attribute_docstrings=True)
     _ee: EventEmitter = PrivateAttr(
         default_factory=lambda: EventEmitter(
-            delimiter=configs.pymitter.delimiter,
-            new_listener=configs.pymitter.new_listener_event,
-            max_listeners=configs.pymitter.max_listeners,
+            delimiter=CONFIG.pymitter.delimiter,
+            new_listener=CONFIG.pymitter.new_listener_event,
+            max_listeners=CONFIG.pymitter.max_listeners,
             wildcard=True,
         )
     )
@@ -38,11 +36,11 @@ class Env(BaseModel):
 
     @overload
     def on[**P, R](
-        self,
-        event: str | Event,
-        func: Optional[Callable[P, R]] = None,
-        /,
-        ttl: int = -1,
+            self,
+            event: str | Event,
+            func: Optional[Callable[P, R]] = None,
+            /,
+            ttl: int = -1,
     ) -> Callable[[Callable[P, R]], Callable[P, R]]:
         """
         Registers an event listener with a specific function that listens indefinitely or for a specified number of times.
@@ -58,11 +56,11 @@ class Env(BaseModel):
         ...
 
     def on[**P, R](
-        self,
-        event: str | Event,
-        func: Optional[Callable[P, R]] = None,
-        /,
-        ttl=-1,
+            self,
+            event: str | Event,
+            func: Optional[Callable[P, R]] = None,
+            /,
+            ttl=-1,
     ) -> Callable[[Callable[P, R]], Callable[P, R]] | Self:
         """Registers an event listener with a specific function that listens indefinitely or for a specified number of times.
 
@@ -83,8 +81,8 @@ class Env(BaseModel):
 
     @overload
     def once[**P, R](
-        self,
-        event: str | Event,
+            self,
+            event: str | Event,
     ) -> Callable[[Callable[P, R]], Callable[P, R]]:
         """
         Registers an event listener that listens only once.
@@ -99,9 +97,9 @@ class Env(BaseModel):
 
     @overload
     def once[**P, R](
-        self,
-        event: str | Event,
-        func: Callable[[Callable[P, R]], Callable[P, R]],
+            self,
+            event: str | Event,
+            func: Callable[[Callable[P, R]], Callable[P, R]],
     ) -> Self:
         """
         Registers an event listener with a specific function that listens only once.
@@ -116,9 +114,9 @@ class Env(BaseModel):
         ...
 
     def once[**P, R](
-        self,
-        event: str | Event,
-        func: Optional[Callable[P, R]] = None,
+            self,
+            event: str | Event,
+            func: Optional[Callable[P, R]] = None,
     ) -> Callable[[Callable[P, R]], Callable[P, R]] | Self:
         """Registers an event listener with a specific function that listens only once.
 

fabricatio/decorators.py

@@ -8,7 +8,8 @@ from shutil import which
 from types import ModuleType
 from typing import Callable, Coroutine, List, Optional
 
-from fabricatio.config import configs
+from fabricatio.rust import CONFIG
+
 from fabricatio.journal import logger
 
 
@@ -24,7 +25,7 @@ def precheck_package[**P, R](package_name: str, msg: str) -> Callable[[Callable[
     """
 
     def _wrapper(
-        func: Callable[P, R] | Callable[P, Coroutine[None, None, R]],
+            func: Callable[P, R] | Callable[P, Coroutine[None, None, R]],
     ) -> Callable[P, R] | Callable[P, Coroutine[None, None, R]]:
         if iscoroutinefunction(func):
 
@@ -48,7 +49,7 @@ def precheck_package[**P, R](package_name: str, msg: str) -> Callable[[Callable[
 
 
 def depend_on_external_cmd[**P, R](
-    bin_name: str, install_tip: Optional[str], homepage: Optional[str] = None
+        bin_name: str, install_tip: Optional[str], homepage: Optional[str] = None
 ) -> Callable[[Callable[P, R]], Callable[P, R]]:
     """Decorator to check for the presence of an external command.
 
@@ -113,7 +114,7 @@ def confirm_to_execute[**P, R](func: Callable[P, R]) -> Callable[P, Optional[R]]
     Returns:
         Callable: A decorator that wraps the function to confirm before execution.
     """
-    if not configs.general.confirm_on_ops:
+    if not CONFIG.general.confirm_on_ops:
         # Skip confirmation if the configuration is set to False
         return func
     from questionary import confirm
@@ -123,8 +124,8 @@ def confirm_to_execute[**P, R](func: Callable[P, R]) -> Callable[P, Optional[R]]
         @wraps(func)
         async def _wrapper(*args: P.args, **kwargs: P.kwargs) -> Optional[R]:
             if await confirm(
-                f"Are you sure to execute function: {func.__name__}{signature(func)} \n📦 Args:{args}\n🔑 Kwargs:{kwargs}\n",
-                instruction="Please input [Yes/No] to proceed (default: Yes):",
+                    f"Are you sure to execute function: {func.__name__}{signature(func)} \n📦 Args:{args}\n🔑 Kwargs:{kwargs}\n",
+                    instruction="Please input [Yes/No] to proceed (default: Yes):",
             ).ask_async():
                 return await func(*args, **kwargs)
             logger.warning(f"Function: {func.__name__}{signature(func)} canceled by user.")
@@ -135,8 +136,8 @@ def confirm_to_execute[**P, R](func: Callable[P, R]) -> Callable[P, Optional[R]]
         @wraps(func)
         def _wrapper(*args: P.args, **kwargs: P.kwargs) -> Optional[R]:
             if confirm(
-                f"Are you sure to execute function: {func.__name__}{signature(func)} \n📦 Args:{args}\n��� Kwargs:{kwargs}\n",
-                instruction="Please input [Yes/No] to proceed (default: Yes):",
+                    f"Are you sure to execute function: {func.__name__}{signature(func)} \n📦 Args:{args}\n��� Kwargs:{kwargs}\n",
+                    instruction="Please input [Yes/No] to proceed (default: Yes):",
             ).ask():
                 return func(*args, **kwargs)
             logger.warning(f"Function: {func.__name__}{signature(func)} canceled by user.")
@@ -218,7 +219,7 @@ def use_temp_module[**P, R](modules: ModuleType | List[ModuleType]) -> Callable[
 
 
 def logging_exec_time[**P, R](
-    func: Callable[P, R] | Callable[P, Coroutine[None, None, R]],
+        func: Callable[P, R] | Callable[P, Coroutine[None, None, R]],
 ) -> Callable[P, R] | Callable[P, Coroutine[None, None, R]]:
     """Decorator to log the execution time of a function.
 
@@ -231,7 +232,6 @@ def logging_exec_time[**P, R](
     from time import time
 
     if iscoroutinefunction(func):
-
         @wraps(func)
         async def _async_wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
             start_time = time()

fabricatio/fs/__init__.py

@@ -1,7 +1,6 @@
 """FileSystem manipulation module for Fabricatio."""
 from importlib.util import find_spec
 
-from fabricatio.config import configs
 from fabricatio.fs.curd import (
     absolute_path,
     copy_file,
@@ -32,5 +31,5 @@ __all__ = [
 if find_spec("magika"):
     from magika import Magika
 
-    MAGIKA = Magika(model_dir=configs.magika.model_dir)
+    MAGIKA = Magika()
     __all__ += ["MAGIKA"]

fabricatio/journal.py

@@ -2,20 +2,13 @@
 
 import sys
 
+from fabricatio.rust import CONFIG
 from loguru import logger
 from rich import pretty, traceback
 
-from fabricatio.config import configs
-
 pretty.install()
 traceback.install()
 logger.remove()
-logger.add(
-    configs.debug.log_file,
-    level=configs.debug.log_level,
-    rotation=f"{configs.debug.rotation} weeks",
-    retention=f"{configs.debug.retention} weeks",
-)
-logger.add(sys.stderr, level=configs.debug.log_level)
+logger.add(sys.stderr, level=CONFIG.debug.log_level)
 
 __all__ = ["logger"]

fabricatio/models/action.py

@@ -14,12 +14,13 @@ from abc import abstractmethod
 from asyncio import Queue, create_task
 from typing import Any, ClassVar, Dict, Self, Sequence, Tuple, Type, Union, final
 
+from pydantic import Field, PrivateAttr
+
 from fabricatio.journal import logger
 from fabricatio.models.generic import WithBriefing
 from fabricatio.models.task import Task
 from fabricatio.models.usages import ToolBoxUsage
 from fabricatio.utils import override_kwargs
-from pydantic import Field, PrivateAttr
 
 OUTPUT_KEY = "task_output"
 

fabricatio/models/extra/aricle_rag.py

@@ -5,16 +5,17 @@ from itertools import groupby
 from pathlib import Path
 from typing import ClassVar, Dict, List, Optional, Self, Unpack
 
+from fabricatio.rust import BibManager, blake3_hash, split_into_chunks
+from more_itertools.more import first
+from more_itertools.recipes import flatten, unique
+from pydantic import Field
+
 from fabricatio.fs import safe_text_read
 from fabricatio.journal import logger
 from fabricatio.models.extra.rag import MilvusDataBase
 from fabricatio.models.generic import AsPrompt
 from fabricatio.models.kwargs_types import ChunkKwargs
-from fabricatio.rust import BibManager, blake3_hash, split_into_chunks
 from fabricatio.utils import ok, wrapp_in_block
-from more_itertools.more import first
-from more_itertools.recipes import flatten, unique
-from pydantic import Field
 
 
 class ArticleChunk(MilvusDataBase):
@@ -67,7 +68,7 @@ class ArticleChunk(MilvusDataBase):
 
     @classmethod
     def from_file[P: str | Path](
-        cls, path: P | List[P], bib_mgr: BibManager, **kwargs: Unpack[ChunkKwargs]
+            cls, path: P | List[P], bib_mgr: BibManager, **kwargs: Unpack[ChunkKwargs]
     ) -> List[Self]:
         """Load the article chunks from the file."""
         if isinstance(path, list):
@@ -84,9 +85,9 @@ class ArticleChunk(MilvusDataBase):
         title_seg = path.stem.split(" - ").pop()
 
         key = (
-            bib_mgr.get_cite_key_by_title(title_seg)
-            or bib_mgr.get_cite_key_by_title_fuzzy(title_seg)
-            or bib_mgr.get_cite_key_fuzzy(path.stem)
+                bib_mgr.get_cite_key_by_title(title_seg)
+                or bib_mgr.get_cite_key_by_title_fuzzy(title_seg)
+                or bib_mgr.get_cite_key_fuzzy(path.stem)
         )
         if key is None:
             logger.warning(f"no cite key found for {path.as_posix()}, skip.")
@@ -178,7 +179,7 @@ class CitationManager(AsPrompt):
     """Separator for abbreviated citation numbers."""
 
     def update_chunks(
-        self, article_chunks: List[ArticleChunk], set_cite_number: bool = True, dedup: bool = True
+            self, article_chunks: List[ArticleChunk], set_cite_number: bool = True, dedup: bool = True
     ) -> Self:
         """Update article chunks."""
         self.article_chunks.clear()