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

fabricatio/capabilities/propose.py

@@ -1,5 +1,5 @@
 """A module for the task capabilities of the Fabricatio library."""
-
+from abc import ABC
 from typing import List, Optional, Type, Unpack, overload
 
 from fabricatio.models.generic import ProposedAble
@@ -7,7 +7,7 @@ from fabricatio.models.kwargs_types import ValidateKwargs
 from fabricatio.models.usages import LLMUsage
 
 
-class Propose(LLMUsage):
+class Propose(LLMUsage,ABC):
     """A class that proposes an Obj based on a prompt."""
 
     @overload

fabricatio/capabilities/rag.py

@@ -1,5 +1,7 @@
 """A module for the RAG (Retrieval Augmented Generation) model."""
 
+from abc import ABC
+
 try:
     from pymilvus import MilvusClient
 except ImportError as e:
@@ -13,13 +15,12 @@ from typing import List, Optional, Self, Type, Unpack
 from more_itertools.recipes import flatten, unique
 from pydantic import Field, PrivateAttr
 
-from fabricatio.config import configs
 from fabricatio.journal import logger
 from fabricatio.models.adv_kwargs_types import CollectionConfigKwargs, FetchKwargs
 from fabricatio.models.extra.rag import MilvusDataBase
 from fabricatio.models.kwargs_types import ChooseKwargs
 from fabricatio.models.usages import EmbeddingUsage
-from fabricatio.rust_instances import TEMPLATE_MANAGER
+from fabricatio.rust import CONFIG, TEMPLATE_MANAGER
 from fabricatio.utils import ok
 
 
@@ -33,7 +34,7 @@ def create_client(uri: str, token: str = "", timeout: Optional[float] = None) ->
     )
 
 
-class RAG(EmbeddingUsage):
+class RAG(EmbeddingUsage, ABC):
     """A class representing the RAG (Retrieval Augmented Generation) model."""
 
     target_collection: Optional[str] = Field(default=None)
@@ -50,17 +51,17 @@ class RAG(EmbeddingUsage):
         return self._client
 
     def init_client(
-        self,
-        milvus_uri: Optional[str] = None,
-        milvus_token: Optional[str] = None,
-        milvus_timeout: Optional[float] = None,
+            self,
+            milvus_uri: Optional[str] = None,
+            milvus_token: Optional[str] = None,
+            milvus_timeout: Optional[float] = None,
     ) -> Self:
         """Initialize the Milvus client."""
         self._client = create_client(
-            uri=milvus_uri or ok(self.milvus_uri or configs.rag.milvus_uri).unicode_string(),
+            uri=milvus_uri or ok(self.milvus_uri or CONFIG.rag.milvus_uri),
             token=milvus_token
-            or (token.get_secret_value() if (token := (self.milvus_token or configs.rag.milvus_token)) else ""),
-            timeout=milvus_timeout or self.milvus_timeout or configs.rag.milvus_timeout,
+                  or (token.get_secret_value() if (token := (self.milvus_token or CONFIG.rag.milvus_token)) else ""),
+            timeout=milvus_timeout or self.milvus_timeout or CONFIG.rag.milvus_timeout,
         )
         return self
 
@@ -73,7 +74,7 @@ class RAG(EmbeddingUsage):
         return self
 
     def view(
-        self, collection_name: Optional[str], create: bool = False, **kwargs: Unpack[CollectionConfigKwargs]
+            self, collection_name: Optional[str], create: bool = False, **kwargs: Unpack[CollectionConfigKwargs]
     ) -> Self:
         """View the specified collection.
 
@@ -86,9 +87,9 @@ class RAG(EmbeddingUsage):
             kwargs["dimension"] = ok(
                 kwargs.get("dimension")
                 or self.milvus_dimensions
-                or configs.rag.milvus_dimensions
+                or CONFIG.rag.milvus_dimensions
                 or self.embedding_dimensions
-                or configs.embedding.dimensions,
+                or CONFIG.embedding.dimensions,
                 "`dimension` is not set at any level.",
             )
             self.client.create_collection(collection_name, auto_id=True, **kwargs)
@@ -115,7 +116,7 @@ class RAG(EmbeddingUsage):
         return ok(self.target_collection, "No collection is being viewed. Have you called `self.view()`?")
 
     async def add_document[D: MilvusDataBase](
-        self, data: List[D] | D, collection_name: Optional[str] = None, flush: bool = False
+            self, data: List[D] | D, collection_name: Optional[str] = None, flush: bool = False
     ) -> Self:
         """Adds a document to the specified collection.
 
@@ -142,15 +143,15 @@ class RAG(EmbeddingUsage):
         return self
 
     async def afetch_document[D: MilvusDataBase](
-        self,
-        query: List[str],
-        document_model: Type[D],
-        collection_name: Optional[str] = None,
-        similarity_threshold: float = 0.37,
-        result_per_query: int = 10,
-        tei_endpoint: Optional[str] = None,
-        reranker_threshold: float = 0.7,
-        filter_expr: str = "",
+            self,
+            query: List[str],
+            document_model: Type[D],
+            collection_name: Optional[str] = None,
+            similarity_threshold: float = 0.37,
+            result_per_query: int = 10,
+            tei_endpoint: Optional[str] = None,
+            reranker_threshold: float = 0.7,
+            filter_expr: str = "",
     ) -> List[D]:
         """Asynchronously fetches documents from a Milvus database based on input vectors.
 
@@ -163,7 +164,7 @@ class RAG(EmbeddingUsage):
            result_per_query (int): The maximum number of results to return per query. Defaults to 10.
            tei_endpoint (str): the endpoint of the TEI api.
            reranker_threshold (float): The threshold used to filtered low relativity document.
-            filter_expr (str): filter_expression parsed into pymilvus search.
+           filter_expr (str) : The filter expression used to filter out unwanted documents.
 
         Returns:
            List[D]: A list of document objects created from the fetched data.
@@ -178,9 +179,9 @@ class RAG(EmbeddingUsage):
             limit=result_per_query,
         )
         if tei_endpoint is not None:
-            from fabricatio.utils import RerankerAPI
+            from fabricatio.rust import TEIClient
 
-            reranker = RerankerAPI(base_url=tei_endpoint)
+            reranker = TEIClient(base_url=tei_endpoint)
 
             retrieved_id = set()
             raw_result = []
@@ -191,10 +192,9 @@ class RAG(EmbeddingUsage):
                 retrieved_id.update(res["id"] for res in g)
                 if not models:
                     continue
-                rank_scores = await reranker.arerank(q, [m.prepare_vectorization() for m in models], truncate=True)
-                raw_result.extend(
-                    (models[s["index"]], s["score"]) for s in rank_scores if s["score"] > reranker_threshold
-                )
+                rank_scores = await reranker.arerank(q, [m.prepare_vectorization() for m in models], truncate=True,
+                                                     truncation_direction="Left")
+                raw_result.extend((models[idx], scr) for (idx, scr) in rank_scores if scr > reranker_threshold)
 
             raw_result_sorted = sorted(raw_result, key=lambda x: x[1], reverse=True)
             return [r[0] for r in raw_result_sorted]
@@ -215,11 +215,11 @@ class RAG(EmbeddingUsage):
         return document_model.from_sequence(resp)
 
     async def aretrieve[D: MilvusDataBase](
-        self,
-        query: List[str] | str,
-        document_model: Type[D],
-        max_accepted: int = 20,
-        **kwargs: Unpack[FetchKwargs],
+            self,
+            query: List[str] | str,
+            document_model: Type[D],
+            max_accepted: int = 20,
+            **kwargs: Unpack[FetchKwargs],
     ) -> List[D]:
         """Retrieve data from the collection.
 
@@ -236,15 +236,15 @@ class RAG(EmbeddingUsage):
             query = [query]
 
         return (
-            await self.afetch_document(
-                query=query,
-                document_model=document_model,
-                **kwargs,
-            )
-        )[:max_accepted]
+                   await self.afetch_document(
+                       query=query,
+                       document_model=document_model,
+                       **kwargs,
+                   )
+               )[:max_accepted]
 
     async def arefined_query(
-        self, question: List[str] | str, **kwargs: Unpack[ChooseKwargs[Optional[List[str]]]]
+            self, question: List[str] | str, **kwargs: Unpack[ChooseKwargs[Optional[List[str]]]]
     ) -> Optional[List[str]]:
         """Refines the given question using a template.
 
@@ -257,7 +257,7 @@ class RAG(EmbeddingUsage):
         """
         return await self.alist_str(
             TEMPLATE_MANAGER.render_template(
-                configs.templates.refined_query_template,
+                CONFIG.templates.refined_query_template,
                 {"question": [question] if isinstance(question, str) else question},
             ),
             **kwargs,

fabricatio/capabilities/rating.py

@@ -1,5 +1,6 @@
 """A module that provides functionality to rate tasks based on a rating manual and score range."""
 
+from abc import ABC
 from itertools import permutations
 from random import sample
 from typing import Dict, List, Optional, Set, Tuple, Union, Unpack, overload
@@ -8,16 +9,15 @@ 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.rust import CONFIG, TEMPLATE_MANAGER
 from fabricatio.utils import ok, override_kwargs
 
 
-class Rating(Propose):
+class Rating(Propose, ABC):
     """A class that provides functionality to rate tasks based on a rating manual and score range.
 
     References:
@@ -66,13 +66,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
@@ -171,7 +171,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),
@@ -201,7 +201,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,
@@ -251,7 +251,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 +271,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),
@@ -311,7 +311,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],
@@ -370,6 +370,7 @@ class Rating(Propose):
 
     @overload
     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]

fabricatio/capabilities/review.py

@@ -1,19 +1,19 @@
 """A module that provides functionality to rate tasks based on a rating manual and score range."""
 
+from abc import ABC
 from typing import Dict, Optional, Set, Unpack
 
 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.rust import CONFIG, TEMPLATE_MANAGER
 from fabricatio.utils import ok
 
 
-class Review(Rating, Propose):
+class Review(Rating, Propose, ABC):
     """Class that provides functionality to review tasks and strings using a language model.
 
     This class extends GiveRating and Propose capabilities to analyze content,
@@ -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,15 @@ 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

@@ -1,28 +1,28 @@
 """A module for the task capabilities of the Fabricatio library."""
 
+from abc import ABC
 from types import CodeType
 from typing import Any, Dict, List, Optional, Tuple, Unpack
 
 import ujson
 
 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
+from fabricatio.rust import CONFIG, TEMPLATE_MANAGER
 
 
-class ProposeTask(Propose):
+class ProposeTask(Propose, ABC):
     """A class that proposes a task based on a prompt."""
 
     async def propose_task[T](
-            self,
-            prompt: str,
-            **kwargs: Unpack[ValidateKwargs[Task[T]]],
+        self,
+        prompt: str,
+        **kwargs: Unpack[ValidateKwargs[Task[T]]],
     ) -> Optional[Task[T]]:
         """Asynchronously proposes a task based on a given prompt and parameters.
 
@@ -40,15 +40,15 @@ class ProposeTask(Propose):
         return await self.propose(Task, prompt, **kwargs)
 
 
-class HandleTask(ToolBoxUsage):
+class HandleTask(ToolBoxUsage,ABC):
     """A class that handles a task based on a task object."""
 
     async def draft_tool_usage_code(
-            self,
-            task: Task,
-            tools: List[Tool],
-            data: Dict[str, Any],
-            **kwargs: Unpack[ValidateKwargs],
+        self,
+        task: Task,
+        tools: List[Tool],
+        data: Dict[str, Any],
+        **kwargs: Unpack[ValidateKwargs],
     ) -> Optional[Tuple[CodeType, List[str]]]:
         """Asynchronously drafts the tool usage code for a task based on a given task object and tools."""
         logger.info(f"Drafting tool usage code for task: {task.briefing}")
@@ -60,17 +60,17 @@ class HandleTask(ToolBoxUsage):
 
         def _validator(response: str) -> Tuple[CodeType, List[str]] | None:
             if (source := PythonCapture.convert_with(response, lambda resp: compile(resp, "<string>", "exec"))) and (
-                    to_extract := JsonCapture.convert_with(response, ujson.loads)
+                to_extract := JsonCapture.convert_with(response, ujson.loads)
             ):
                 return source, to_extract
 
             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],
@@ -85,12 +85,12 @@ class HandleTask(ToolBoxUsage):
         )
 
     async def handle_fine_grind(
-            self,
-            task: Task,
-            data: Dict[str, Any],
-            box_choose_kwargs: Optional[ChooseKwargs] = None,
-            tool_choose_kwargs: Optional[ChooseKwargs] = None,
-            **kwargs: Unpack[ValidateKwargs],
+        self,
+        task: Task,
+        data: Dict[str, Any],
+        box_choose_kwargs: Optional[ChooseKwargs] = None,
+        tool_choose_kwargs: Optional[ChooseKwargs] = None,
+        **kwargs: Unpack[ValidateKwargs],
     ) -> Optional[Tuple]:
         """Asynchronously handles a task based on a given task object and parameters."""
         logger.info(f"Handling task: \n{task.briefing}")

fabricatio/decorators.py

@@ -8,8 +8,8 @@ from shutil import which
 from types import ModuleType
 from typing import Callable, Coroutine, List, Optional
 
-from fabricatio.config import configs
 from fabricatio.journal import logger
+from fabricatio.rust import CONFIG
 
 
 def precheck_package[**P, R](package_name: str, msg: str) -> Callable[[Callable[P, R]], Callable[P, R]]:
@@ -113,7 +113,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
@@ -235,6 +235,7 @@ def logging_exec_time[**P, R](
         @wraps(func)
         async def _async_wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
             start_time = time()
+            logger.debug(f"Starting execution of {func.__name__}")
             result = await func(*args, **kwargs)
             logger.debug(f"Execution time of `{func.__name__}`: {time() - start_time:.2f} s")
             return result
@@ -244,6 +245,7 @@ def logging_exec_time[**P, R](
     @wraps(func)
     def _wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
         start_time = time()
+        logger.debug(f"Starting execution of {func.__name__}")
         result = func(*args, **kwargs)
         logger.debug(f"Execution time of {func.__name__}: {(time() - start_time) * 1000:.2f} ms")
         return result

fabricatio/{core.py → emitter.py}

@@ -1,25 +1,21 @@
 """Core module that contains the Env class for managing event handling."""
+from dataclasses import dataclass
+from typing import Callable, ClassVar, Optional, Self, overload
 
-from typing import Callable, Optional, Self, overload
-
-from pydantic import BaseModel, ConfigDict, PrivateAttr
 from pymitter import EventEmitter
 
-from fabricatio.config import configs
-from fabricatio.models.events import Event
+from fabricatio.rust import CONFIG, Event
 
 
-class Env(BaseModel):
+@dataclass
+class Env:
     """Environment class that manages event handling using EventEmitter."""
 
-    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,
-            wildcard=True,
-        )
+    ee: ClassVar[EventEmitter] = EventEmitter(
+        delimiter=CONFIG.pymitter.delimiter,
+        new_listener=CONFIG.pymitter.new_listener_event,
+        max_listeners=CONFIG.pymitter.max_listeners,
+        wildcard=True,
     )
 
     @overload
@@ -38,11 +34,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 +54,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.
 
@@ -77,14 +73,14 @@ class Env(BaseModel):
         if isinstance(event, Event):
             event = event.collapse()
         if func is None:
-            return self._ee.on(event, ttl=ttl)
-        self._ee.on(event, func, ttl=ttl)
+            return self.ee.on(event, ttl=ttl)
+        self.ee.on(event, func, ttl=ttl)
         return self
 
     @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 +95,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 +112,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.
 
@@ -132,9 +128,9 @@ class Env(BaseModel):
         if isinstance(event, Event):
             event = event.collapse()
         if func is None:
-            return self._ee.once(event)
+            return self.ee.once(event)
 
-        self._ee.once(event, func)
+        self.ee.once(event, func)
         return self
 
     def emit[**P](self, event: str | Event, *args: P.args, **kwargs: P.kwargs) -> None:
@@ -148,7 +144,7 @@ class Env(BaseModel):
         if isinstance(event, Event):
             event = event.collapse()
 
-        self._ee.emit(event, *args, **kwargs)
+        self.ee.emit(event, *args, **kwargs)
 
     async def emit_async[**P](self, event: str | Event, *args: P.args, **kwargs: P.kwargs) -> None:
         """Asynchronously emits an event to all registered listeners.
@@ -160,7 +156,7 @@ class Env(BaseModel):
         """
         if isinstance(event, Event):
             event = event.collapse()
-        return await self._ee.emit_async(event, *args, **kwargs)
+        return await self.ee.emit_async(event, *args, **kwargs)
 
     def emit_future[**P](self, event: str | Event, *args: P.args, **kwargs: P.kwargs) -> None:
         """Emits an event to all registered listeners and returns a future object.
@@ -175,7 +171,7 @@ class Env(BaseModel):
         """
         if isinstance(event, Event):
             event = event.collapse()
-        return self._ee.emit_future(event, *args, **kwargs)
+        return self.ee.emit_future(event, *args, **kwargs)
 
 
 env = Env()

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

@@ -3,19 +3,10 @@
 import sys
 
 from loguru import logger
-from rich import pretty, traceback
 
-from fabricatio.config import configs
+from fabricatio.rust import CONFIG
 
-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"]