fabricatio 0.2.10.dev0__cp312-cp312-win_amd64.whl → 0.2.10.dev1__cp312-cp312-win_amd64.whl

fabricatio/actions/article.py

@@ -4,6 +4,7 @@ from asyncio import gather
 from pathlib import Path
 from typing import Callable, List, Optional
 
+from fabricatio.rust import BibManager, detect_language
 from more_itertools import filter_map
 
 from fabricatio.capabilities.censor import Censor
@@ -17,7 +18,6 @@ from fabricatio.models.extra.article_outline import ArticleOutline
 from fabricatio.models.extra.article_proposal import ArticleProposal
 from fabricatio.models.extra.rule import RuleSet
 from fabricatio.models.task import Task
-from fabricatio.rust import BibManager, detect_language
 from fabricatio.utils import ok
 
 
@@ -78,7 +78,7 @@ class FixArticleEssence(Action):
         out = []
         count = 0
         for a in article_essence:
-            if key := (bib_mgr.get_cite_key(a.title) or bib_mgr.get_cite_key_fuzzy(a.title)):
+            if key := (bib_mgr.get_cite_key_by_title(a.title) or bib_mgr.get_cite_key_fuzzy(a.title)):
                 a.title = bib_mgr.get_title_by_key(key) or a.title
                 a.authors = bib_mgr.get_author_by_key(key) or a.authors
                 a.publication_year = bib_mgr.get_year_by_key(key) or a.publication_year

fabricatio/actions/article_rag.py

@@ -1,11 +1,15 @@
 """A module for writing articles using RAG (Retrieval-Augmented Generation) capabilities."""
 
 from asyncio import gather
-from typing import Optional
+from pathlib import Path
+from typing import List, Optional
 
+from fabricatio import BibManager
 from fabricatio.capabilities.censor import Censor
 from fabricatio.capabilities.rag import RAG
 from fabricatio.models.action import Action
+from fabricatio.models.extra.aricle_rag import ArticleChunk
+from fabricatio.models.extra.article_essence import ArticleEssence
 from fabricatio.models.extra.article_main import Article, ArticleSubsection
 from fabricatio.models.extra.rule import RuleSet
 from fabricatio.utils import ok
@@ -97,9 +101,36 @@ class TweakArticleRAG(Action, RAG, Censor):
         await self.censor_obj_inplace(
             subsec,
             ruleset=ruleset,
-            reference=f"{await self.aretrieve_compact(refind_q, final_limit=self.ref_limit)}\n\n"
+            reference=f"{'\n\n'.join(d.display() for d in await self.aretrieve(refind_q, document_model=ArticleEssence, final_limit=self.ref_limit))}\n\n"
             f"You can use Reference above to rewrite the `{subsec.__class__.__name__}`.\n"
             f"You should Always use `{subsec.language}` as written language, "
             f"which is the original language of the `{subsec.title}`. "
             f"since rewrite a `{subsec.__class__.__name__}` in a different language is usually a bad choice",
         )
+
+
+class ChunkArticle(Action):
+    """Chunk an article into smaller chunks."""
+
+    output_key:str = "article_chunks"
+    """The key used to store the output of the action."""
+    max_chunk_size: Optional[int] = None
+    """The maximum size of each chunk."""
+    max_overlapping_rate: Optional[float] = None
+    """The maximum overlapping rate between chunks."""
+
+    async def _execute(
+        self,
+        article_path: str | Path,
+        bib_manager: BibManager,
+        max_chunk_size: Optional[int] = None,
+        max_overlapping_rate: Optional[float] = None,
+        **_,
+    ) -> List[ArticleChunk]:
+        return ArticleChunk.from_file(
+            article_path,
+            bib_manager,
+            max_chunk_size=ok(max_chunk_size or self.max_chunk_size, "No max_chunk_size provided!"),
+            max_overlapping_rate=ok(max_overlapping_rate or self.max_overlapping_rate, "No max_overlapping_rate provided!"),
+        )
+

fabricatio/actions/rag.py

@@ -5,34 +5,56 @@ from typing import List, Optional
 from questionary import text
 
 from fabricatio.capabilities.rag import RAG
+from fabricatio.config import configs
 from fabricatio.journal import logger
 from fabricatio.models.action import Action
-from fabricatio.models.generic import Vectorizable
+from fabricatio.models.extra.rag import MilvusClassicModel, MilvusDataBase
 from fabricatio.models.task import Task
+from fabricatio.utils import ok
 
 
 class InjectToDB(Action, RAG):
     """Inject data into the database."""
 
     output_key: str = "collection_name"
+    collection_name: str = "my_collection"
+    """The name of the collection to inject data into."""
 
-    async def _execute[T: Vectorizable](
-        self, to_inject: Optional[T] | List[Optional[T]], collection_name: str = "my_collection",override_inject:bool=False, **_
+    async def _execute[T: MilvusDataBase](
+        self, to_inject: Optional[T] | List[Optional[T]], override_inject: bool = False, **_
     ) -> Optional[str]:
+        from pymilvus.milvus_client import IndexParams
+
+        if to_inject is None:
+            return None
         if not isinstance(to_inject, list):
             to_inject = [to_inject]
-        logger.info(f"Injecting {len(to_inject)} items into the collection '{collection_name}'")
+        if not (seq := [t for t in to_inject if t is not None]):  # filter out None
+            return None
+        logger.info(f"Injecting {len(seq)} items into the collection '{self.collection_name}'")
         if override_inject:
-            self.check_client().client.drop_collection(collection_name)
-        await self.view(collection_name, create=True).consume_string(
-            [
-                t.prepare_vectorization(self.embedding_max_sequence_length)
-                for t in to_inject
-                if isinstance(t, Vectorizable)
-            ],
-        )
-
-        return collection_name
+            self.check_client().client.drop_collection(self.collection_name)
+
+        await self.view(
+            self.collection_name,
+            create=True,
+            schema=seq[0].as_milvus_schema(
+                ok(
+                    self.milvus_dimensions
+                    or configs.rag.milvus_dimensions
+                    or self.embedding_dimensions
+                    or configs.embedding.dimensions
+                ),
+            ),
+            index_params=IndexParams(
+                seq[0].vector_field_name,
+                index_name=seq[0].vector_field_name,
+                index_type=seq[0].index_type,
+                metric_type=seq[0].metric_type,
+            ),
+        ).add_document(seq, flush=True)
+
+        return self.collection_name
 
 
 class RAGTalk(Action, RAG):
@@ -62,10 +84,10 @@ class RAGTalk(Action, RAG):
                 user_say = await text("User: ").ask_async()
                 if user_say is None:
                     break
-                gpt_say = await self.aask_retrieved(
-                    user_say,
-                    user_say,
-                    extra_system_message=f"You have to answer to user obeying task assigned to you:\n{task_input.briefing}",
+                ret: List[MilvusClassicModel] = await self.aretrieve(user_say, document_model=MilvusClassicModel)
+
+                gpt_say = await self.aask(
+                    user_say, system_message="\n".join(m.text for m in ret) + "\nYou can refer facts provided above."
                 )
                 print(f"GPT: {gpt_say}")  # noqa: T201
                 counter += 1

fabricatio/capabilities/rag.py

@@ -130,7 +130,7 @@ class RAG(EmbeddingUsage):
         if isinstance(data, MilvusDataBase):
             data = [data]
 
-        data_vec = await self.vectorize([d.to_vectorize for d in data])
+        data_vec = await self.vectorize([d.prepare_vectorization() for d in data])
         prepared_data = [d.prepare_insertion(vec) for d, vec in zip(data, data_vec, strict=True)]
 
         c_name = collection_name or self.safe_target_collection
@@ -188,13 +188,15 @@ class RAG(EmbeddingUsage):
     async def aretrieve[D: MilvusDataBase](
         self,
         query: List[str] | str,
+        document_model: Type[D],
         final_limit: int = 20,
-        **kwargs: Unpack[FetchKwargs[D]],
+        **kwargs: Unpack[FetchKwargs],
     ) -> List[D]:
         """Retrieve data from the collection.
 
         Args:
             query (List[str] | str): The query to be used for retrieval.
+            document_model (Type[D]): The model class used to convert retrieved data into document objects.
             final_limit (int): The final limit on the number of results to return.
             **kwargs (Unpack[FetchKwargs]): Additional keyword arguments for retrieval.
 
@@ -206,6 +208,7 @@ class RAG(EmbeddingUsage):
         return (
             await self.afetch_document(
                 vecs=(await self.vectorize(query)),
+                document_model=document_model,
                 **kwargs,
             )
         )[:final_limit]

fabricatio/models/adv_kwargs_types.py

@@ -1,10 +1,9 @@
 """A module containing kwargs types for content correction and checking operations."""
 
 from importlib.util import find_spec
-from typing import Required, Type, TypedDict
+from typing import NotRequired, TypedDict
 
 from fabricatio.models.extra.problem import Improvement
-from fabricatio.models.extra.rag import MilvusDataBase
 from fabricatio.models.extra.rule import RuleSet
 from fabricatio.models.generic import SketchedAble
 from fabricatio.models.kwargs_types import ReferencedKwargs
@@ -49,19 +48,13 @@ if find_spec("pymilvus"):
         schema: CollectionSchema | None
         index_params: IndexParams | None
 
-    class FetchKwargs[D: MilvusDataBase](TypedDict, total=False):
+    class FetchKwargs(TypedDict):
         """Arguments for fetching data from vector collections.
 
         Controls how data is retrieved from vector databases, including filtering
         and result limiting parameters.
         """
 
-        document_model: Required[Type[D]]
-        collection_name: str | None
-        similarity_threshold: float
-        result_per_query: int
-
-    class RetrievalKwargs(FetchKwargs, total=False):
-        """Arguments for retrieval operations."""
-
-        final_limit: int
+        collection_name: NotRequired[str | None]
+        similarity_threshold: NotRequired[float]
+        result_per_query: NotRequired[int]

fabricatio/models/extra/aricle_rag.py

@@ -0,0 +1,120 @@
+"""A Module containing the article rag models."""
+
+from pathlib import Path
+from typing import ClassVar, Dict, List, Self, Unpack
+
+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, split_into_chunks
+from fabricatio.utils import ok, wrapp_in_block
+from more_itertools.recipes import flatten
+from pydantic import Field
+
+
+class ArticleChunk(MilvusDataBase, AsPrompt):
+    """The chunk of an article."""
+
+    head_split: ClassVar[List[str]] = [
+        "引 言",
+        "引言",
+        "绪 论",
+        "绪论",
+        "前言",
+        "INTRODUCTION",
+        "Introduction",
+    ]
+    tail_split: ClassVar[List[str]] = [
+        "参 考 文 献",
+        "参  考  文  献",
+        "参考文献",
+        "REFERENCES",
+        "References",
+        "Bibliography",
+        "Reference",
+    ]
+    chunk: str
+    """The segment of the article"""
+    year: int
+    """The year of the article"""
+    authors: List[str] = Field(default_factory=list)
+    """The authors of the article"""
+    article_title: str
+    """The title of the article"""
+    bibtex_cite_key: str
+    """The bibtex cite key of the article"""
+
+    def _as_prompt_inner(self) -> Dict[str, str]:
+        return {
+            self.article_title: f"{wrapp_in_block(self.chunk, 'Referring Content')}\n"
+            f"Authors: {';'.join(self.authors)}\n"
+            f"Published Year: {self.year}\n"
+            f"Bibtex Key: {self.bibtex_cite_key}\n",
+        }
+
+    def _prepare_vectorization_inner(self) -> str:
+        return self.chunk
+
+    @classmethod
+    def from_file[P: str | Path](
+        cls, path: P | List[P], bib_mgr: BibManager, **kwargs: Unpack[ChunkKwargs]
+    ) -> List[Self]:
+        """Load the article chunks from the file."""
+        if isinstance(path, list):
+            result = list(flatten(cls._from_file_inner(p, bib_mgr, **kwargs) for p in path))
+            logger.debug(f"Number of chunks created from list of files: {len(result)}")
+            return result
+
+        return cls._from_file_inner(path, bib_mgr, **kwargs)
+
+    @classmethod
+    def _from_file_inner(cls, path: str | Path, bib_mgr: BibManager, **kwargs: Unpack[ChunkKwargs]) -> List[Self]:
+        path = Path(path)
+
+        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)
+        )
+        if key is None:
+            logger.warning(f"no cite key found for {path.as_posix()}, skip.")
+            return []
+        authors = ok(bib_mgr.get_author_by_key(key), f"no author found for {key}")
+        year = ok(bib_mgr.get_year_by_key(key), f"no year found for {key}")
+        article_title = ok(bib_mgr.get_title_by_key(key), f"no title found for {key}")
+
+        result = [
+            cls(chunk=c, year=year, authors=authors, article_title=article_title, bibtex_cite_key=key)
+            for c in split_into_chunks(cls.strip(safe_text_read(path)), **kwargs)
+        ]
+        logger.debug(f"Number of chunks created from file {path.as_posix()}: {len(result)}")
+        return result
+
+    @classmethod
+    def strip(cls, string: str) -> str:
+        """Strip the head and tail of the string."""
+        logger.debug(f"String length before strip: {(original := len(string))}")
+        for split in (s for s in cls.head_split if s in string):
+            logger.debug(f"Strip head using {split}")
+            parts = string.split(split)
+            string = split.join(parts[1:]) if len(parts) > 1 else parts[0]
+            break
+        logger.debug(
+            f"String length after head strip: {(stripped_len := len(string))}, decreased by {(d := original - stripped_len)}"
+        )
+        if not d:
+            logger.warning("No decrease at head strip, which is might be abnormal.")
+        for split in (s for s in cls.tail_split if s in string):
+            logger.debug(f"Strip tail using {split}")
+            parts = string.split(split)
+            string = split.join(parts[:-1]) if len(parts) > 1 else parts[0]
+            break
+        logger.debug(f"String length after tail strip: {len(string)}, decreased by {(d := stripped_len - len(string))}")
+        if not d:
+            logger.warning("No decrease at tail strip, which is might be abnormal.")
+
+        return string

fabricatio/models/extra/article_essence.py

@@ -1,8 +1,9 @@
 """ArticleEssence: Semantic fingerprint of academic paper for structured analysis."""
 
-from typing import List, Self
+from typing import List
 
-from fabricatio.models.generic import Display, PersistentAble, ProposedAble, Vectorizable
+from fabricatio.models.extra.rag import MilvusDataBase
+from fabricatio.models.generic import PersistentAble, SketchedAble
 from pydantic import BaseModel
 
 
@@ -54,7 +55,7 @@ class Highlightings(BaseModel):
     """
 
 
-class ArticleEssence(ProposedAble, Display, PersistentAble, Vectorizable):
+class ArticleEssence(SketchedAble, PersistentAble, MilvusDataBase):
     """Structured representation of a scientific article's core elements in its original language."""
 
     language: str
@@ -93,7 +94,7 @@ class ArticleEssence(ProposedAble, Display, PersistentAble, Vectorizable):
     bibtex_cite_key: str
     """Bibtex cite key of the original article."""
 
-    def update_cite_key(self, new_cite_key: str) -> Self:
-        """Update the bibtex_cite_key of the article."""
-        self.bibtex_cite_key = new_cite_key
-        return self
+    def _prepare_vectorization_inner(self) -> str:
+        return self.compact()
+
+

fabricatio/models/extra/rag.py

@@ -1,10 +1,13 @@
 """A module containing the RAG (Retrieval-Augmented Generation) models."""
 
-from abc import ABCMeta, abstractmethod
-from typing import TYPE_CHECKING, Any, ClassVar, Dict, List, Self, Sequence
+from abc import ABC
+from functools import partial
+from typing import TYPE_CHECKING, Any, ClassVar, Dict, List, Self, Sequence, Set
 
 from fabricatio.decorators import precheck_package
-from pydantic import BaseModel, ConfigDict, JsonValue
+from fabricatio.models.generic import Vectorizable
+from fabricatio.utils import ok
+from pydantic import JsonValue
 
 if TYPE_CHECKING:
     from importlib.util import find_spec
@@ -15,14 +18,18 @@ if TYPE_CHECKING:
         from pymilvus import CollectionSchema
 
 
-class MilvusDataBase(BaseModel, metaclass=ABCMeta):
+class MilvusDataBase(Vectorizable, ABC):
     """A base class for Milvus data."""
 
-    model_config = ConfigDict(use_attribute_docstrings=True)
-
     primary_field_name: ClassVar[str] = "id"
-
+    """The name of the primary field in Milvus."""
     vector_field_name: ClassVar[str] = "vector"
+    """The name of the vector field in Milvus."""
+
+    index_type: ClassVar[str] = "FLAT"
+    """The type of index to be used in Milvus."""
+    metric_type: ClassVar[str] = "COSINE"
+    """The type of metric to be used in Milvus."""
 
     def prepare_insertion(self, vector: List[float]) -> Dict[str, Any]:
         """Prepares the data for insertion into Milvus.
@@ -32,11 +39,6 @@ class MilvusDataBase(BaseModel, metaclass=ABCMeta):
         """
         return {**self.model_dump(exclude_none=True, by_alias=True), self.vector_field_name: vector}
 
-    @property
-    @abstractmethod
-    def to_vectorize(self) -> str:
-        """The text representation of the data."""
-
     @classmethod
     @precheck_package(
         "pymilvus", "pymilvus is not installed. Have you installed `fabricatio[rag]` instead of `fabricatio`?"
@@ -50,23 +52,47 @@ class MilvusDataBase(BaseModel, metaclass=ABCMeta):
             FieldSchema(cls.vector_field_name, dtype=DataType.FLOAT_VECTOR, dim=dimension),
         ]
 
-        type_mapping = {
-            str: DataType.STRING,
-            int: DataType.INT64,
-            float: DataType.DOUBLE,
-            JsonValue: DataType.JSON,
-            # TODO add more mapping
-        }
-
         for k, v in cls.model_fields.items():
             k: str
             v: FieldInfo
-            fields.append(
-                FieldSchema(k, dtype=type_mapping.get(v.annotation, DataType.UNKNOWN), description=v.description or "")
-            )
+            schema = partial(FieldSchema, k, description=v.description or "")
+            anno = ok(v.annotation)
+
+            if anno == int:
+                fields.append(schema(dtype=DataType.INT64))
+            elif anno == str:
+                fields.append(schema(dtype=DataType.VARCHAR, max_length=65535))
+            elif anno == float:
+                fields.append(schema(dtype=DataType.DOUBLE))
+            elif anno == list[str] or anno == List[str] or anno == set[str] or anno == Set[str]:
+                fields.append(
+                    schema(dtype=DataType.ARRAY, element_type=DataType.VARCHAR, max_length=65535, max_capacity=4096)
+                )
+            elif anno == list[int] or anno == List[int] or anno == set[int] or anno == Set[int]:
+                fields.append(schema(dtype=DataType.ARRAY, element_type=DataType.INT64, max_capacity=4096))
+            elif anno == list[float] or anno == List[float] or anno == set[float] or anno == Set[float]:
+                fields.append(schema(dtype=DataType.ARRAY, element_type=DataType.DOUBLE, max_capacity=4096))
+            elif anno == JsonValue:
+                fields.append(schema(dtype=DataType.JSON))
+
+            else:
+                raise NotImplementedError(f"{k}:{anno} is not supported")
+
         return CollectionSchema(fields)
 
     @classmethod
     def from_sequence(cls, data: Sequence[Dict[str, Any]]) -> List[Self]:
         """Constructs a list of instances from a sequence of dictionaries."""
         return [cls(**d) for d in data]
+
+
+class MilvusClassicModel(MilvusDataBase):
+    """A class representing a classic model stored in Milvus."""
+
+    text: str
+    """The text to be stored in Milvus."""
+    subject: str = ""
+    """The subject of the text."""
+
+    def _prepare_vectorization_inner(self) -> str:
+        return self.text

fabricatio/models/generic.py

@@ -6,7 +6,6 @@ from pathlib import Path
 from typing import Any, Callable, Dict, Iterable, List, Optional, Self, Type, Union, final, overload
 
 import orjson
-import rtoml
 from fabricatio.config import configs
 from fabricatio.fs.readers import MAGIKA, safe_text_read
 from fabricatio.journal import logger
@@ -53,7 +52,7 @@ class Display(Base):
         Returns:
             str: JSON string with 1-level indentation for readability
         """
-        return self.model_dump_json(indent=1,by_alias=True)
+        return self.model_dump_json(indent=1, by_alias=True)
 
     def compact(self) -> str:
         """Generate compact JSON representation.
@@ -225,7 +224,7 @@ class PersistentAble(Base):
             - Hash generated from JSON content ensures uniqueness
         """
         p = Path(path)
-        out = self.model_dump_json(indent=1,by_alias=True)
+        out = self.model_dump_json(indent=1, by_alias=True)
 
         # Generate a timestamp in the format YYYYMMDD_HHMMSS
         timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
@@ -299,16 +298,18 @@ class Language(Base):
     """Class that provides a language attribute."""
 
     @property
-    def language(self)->str:
+    def language(self) -> str:
         """Get the language of the object."""
-        if isinstance(self,Described):
+        if isinstance(self, Described):
             return detect_language(self.description)
-        if isinstance(self,Titled):
+        if isinstance(self, Titled):
             return detect_language(self.title)
-        if isinstance(self,Named):
+        if isinstance(self, Named):
             return detect_language(self.name)
 
         return detect_language(self.model_dump_json(by_alias=True))
+
+
 class ModelHash(Base):
     """Class that provides a hash value for the object.
 
@@ -550,7 +551,7 @@ class FinalizedDumpAble(Base):
         Returns:
             str: The finalized dump of the object.
         """
-        return self.model_dump_json(indent=1,by_alias=True)
+        return self.model_dump_json(indent=1, by_alias=True)
 
     def finalized_dump_to(self, path: str | Path) -> Self:
         """Finalize the dump of the object to a file.
@@ -662,8 +663,9 @@ class Vectorizable(Base):
     This class includes methods to prepare the model for vectorization, ensuring it fits within a specified token length.
     """
 
+    @abstractmethod
     def _prepare_vectorization_inner(self) -> str:
-        return rtoml.dumps(self.model_dump())
+        """Prepare the model for vectorization."""
 
     @final
     def prepare_vectorization(self, max_length: Optional[int] = None) -> str:
@@ -681,8 +683,7 @@ class Vectorizable(Base):
         max_length = max_length or configs.embedding.max_sequence_length
         chunk = self._prepare_vectorization_inner()
         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)
+            raise ValueError(f"Chunk exceeds maximum sequence length {max_length}, got {length}, see \n{chunk}")
 
         return chunk
 

fabricatio/models/kwargs_types.py

@@ -1,11 +1,18 @@
 """This module contains the types for the keyword arguments of the methods in the models module."""
 
-from typing import Any, Dict, List, Optional, Required, TypedDict
+from typing import Any, Dict, List, NotRequired, Optional, Required, TypedDict
 
 from litellm.caching.caching import CacheMode
 from litellm.types.caching import CachingSupportedCallTypes
 
 
+class ChunkKwargs(TypedDict):
+    """Configuration parameters for chunking operations."""
+
+    max_chunk_size: int
+    max_overlapping_rate: NotRequired[float]
+
+
 class EmbeddingKwargs(TypedDict, total=False):
     """Configuration parameters for text embedding operations.
 

fabricatio/rust.pyi

@@ -147,7 +147,7 @@ class BibManager:
             RuntimeError: If file cannot be read or parsed
         """
 
-    def get_cite_key(self, title: str) -> Optional[str]:
+    def get_cite_key_by_title(self, title: str) -> Optional[str]:
         """Find citation key by exact title match.
 
         Args:
@@ -156,6 +156,15 @@ class BibManager:
         Returns:
             Citation key if exact match found, None otherwise
         """
+    def get_cite_key_by_title_fuzzy(self, title: str) -> Optional[str]:
+        """Find citation key by fuzzy title match.
+
+        Args:
+            title: Search term to find in bibliography entries
+
+        Returns:
+            Citation key of best matching entry, or None if no good match
+        """
 
     def get_cite_key_fuzzy(self, query: str) -> Optional[str]:
         """Find best matching citation using fuzzy text search.

fabricatio/utils.py

@@ -25,7 +25,7 @@ async def ask_edit(
     return res
 
 
-def override_kwargs(kwargs: Mapping[str,Any], **overrides) -> Dict[str, Any]:
+def override_kwargs(kwargs: Mapping[str, Any], **overrides) -> Dict[str, Any]:
     """Override the values in kwargs with the provided overrides."""
     new_kwargs = dict(kwargs.items())
     new_kwargs.update({k: v for k, v in overrides.items() if v is not None})
@@ -52,3 +52,16 @@ def ok[T](val: Optional[T], msg: str = "Value is None") -> T:
     if val is None:
         raise ValueError(msg)
     return val
+
+
+def wrapp_in_block(string: str, title: str) -> str:
+    """Wraps a string in a block with a title.
+
+    Args:
+        string: The string to wrap.
+        title: The title of the block.
+
+    Returns:
+        str: The wrapped string.
+    """
+    return f"--- Start of {title} ---\n{string}\n--- End of {title} ---"

{fabricatio-0.2.10.dev0.dist-info → fabricatio-0.2.10.dev1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fabricatio
-Version: 0.2.10.dev0
+Version: 0.2.10.dev1
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: 3.12
@@ -23,7 +23,6 @@ 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'
@@ -45,8 +44,6 @@ Project-URL: Issues, https://github.com/Whth/fabricatio/issues
 # Fabricatio
 
 ![MIT License](https://img.shields.io/badge/license-MIT-blue.svg)
-![Python 3.12+](https://img.shields.io/badge/python-3.12+-blue.svg)
-![Build Status](https://img.shields.io/badge/build-passing-brightgreen)
 
 ## Overview
 

{fabricatio-0.2.10.dev0.dist-info → fabricatio-0.2.10.dev1.dist-info}/RECORD

@@ -1,10 +1,10 @@
-fabricatio-0.2.10.dev0.dist-info/METADATA,sha256=P8fqqWkcxcC1a42_I3GdmnP6qB8ZKsGoqyn4u-9yRT4,5289
-fabricatio-0.2.10.dev0.dist-info/WHEEL,sha256=jABKVkLC9kJr8mi_er5jOqpiQUjARSLXDUIIxDqsS50,96
-fabricatio-0.2.10.dev0.dist-info/licenses/LICENSE,sha256=do7J7EiCGbq0QPbMAL_FqLYufXpHnCnXBOuqVPwSV8Y,1088
-fabricatio/actions/article.py,sha256=C4t3hB5_k4dDrVuLzVTJIp3D6XyvvlRyGIov5-mNows,8984
-fabricatio/actions/article_rag.py,sha256=itGH-VCKTVFm7hrYIOOT4FyFXP8CbL042kpYNI9a2BE,4735
+fabricatio-0.2.10.dev1.dist-info/METADATA,sha256=HRPFnRmPH19wYpcE1dJoL6Kltg2vewsF432CMSqV-Yg,5118
+fabricatio-0.2.10.dev1.dist-info/WHEEL,sha256=jABKVkLC9kJr8mi_er5jOqpiQUjARSLXDUIIxDqsS50,96
+fabricatio-0.2.10.dev1.dist-info/licenses/LICENSE,sha256=do7J7EiCGbq0QPbMAL_FqLYufXpHnCnXBOuqVPwSV8Y,1088
+fabricatio/actions/article.py,sha256=0PE-b47WvBQpa4XPwc4sMe11GY8KO71N4pui_Yrnz_I,8993
+fabricatio/actions/article_rag.py,sha256=79466dKS1TaT2rw5gadM1WfZoRJy07LmtoMXvfCZ2-U,5952
 fabricatio/actions/output.py,sha256=gkC2u_VpMJ6jOnbyRAJN24UVK7iDAMzhItYukaW8Spk,6498
-fabricatio/actions/rag.py,sha256=5nSih3YUkdt1uU02hSAMW6sADq9mkMOR1wDv7zIrIGQ,2737
+fabricatio/actions/rag.py,sha256=9fM4oR5B4AJNhKmWfUlNIeF4QkUntQscICNVo_zWPSA,3580
 fabricatio/actions/rules.py,sha256=SNvAvQx4xUare16Za_dEpYlYI_PJNnbiO-E0XDa5JT4,2857
 fabricatio/actions/__init__.py,sha256=wVENCFtpVb1rLFxoOFJt9-8smLWXuJV7IwA8P3EfFz4,48
 fabricatio/capabilities/advanced_judge.py,sha256=selB0Gwf1F4gGJlwBiRo6gI4KOUROgh3WnzO3mZFEls,706
@@ -12,7 +12,7 @@ fabricatio/capabilities/censor.py,sha256=bBT5qy-kp7fh8g4Lz3labSwxwJ60gGd_vrkc6k1
 fabricatio/capabilities/check.py,sha256=kYqzohhv2bZfl1aKSUt7a8snT8YEl2zgha_ZdAdMMfQ,8622
 fabricatio/capabilities/correct.py,sha256=W_cInqlciNEhyMK0YI53jk4EvW9uAdge90IO9OElUmA,10420
 fabricatio/capabilities/propose.py,sha256=hkBeSlmcTdfYWT-ph6nlbtHXBozi_JXqXlWcnBy3W78,2007
-fabricatio/capabilities/rag.py,sha256=eWA4lDs6lnBFCK80H1JF68yOe7oScydQekXlBs2X0OI,9396
+fabricatio/capabilities/rag.py,sha256=kqcunWBC6oA4P1rzIG2Xu9zqSg73H3uKPF41JJQ1HVI,9595
 fabricatio/capabilities/rating.py,sha256=Wt_H5fA1H4XuZGIMI8pr0cp_6jnXJABlo8lfU_4Fp5A,17645
 fabricatio/capabilities/review.py,sha256=-EMZe0ADFPT6fPGmra16UPjJC1M3rAs6dPFdTZ88Fgg,5060
 fabricatio/capabilities/task.py,sha256=JahC61X233UIPsjovxJgc_yqj_BjWZJBCzJZq11M2Xk,4417
@@ -26,37 +26,38 @@ fabricatio/fs/readers.py,sha256=M5kojKWsJQMQpE4CBbYvas0JKmPaiaYSfWmiqJx1SP4,1884
 fabricatio/fs/__init__.py,sha256=PCf0s_9KDjVfNw7AfPoJzGt3jMq4gJOfbcT4pb0D0ZY,588
 fabricatio/journal.py,sha256=stnEP88aUBA_GmU9gfTF2EZI8FS2OyMLGaMSTgK4QgA,476
 fabricatio/models/action.py,sha256=Kfa-zojgHQ1vPoC2lQp-thTTp0oySKn7k6I4ea6iYTs,9837
-fabricatio/models/adv_kwargs_types.py,sha256=YojZbB7m7VHA8woYnJpkLF4zPF2aYqv__SnCMK2cG-o,2180
+fabricatio/models/adv_kwargs_types.py,sha256=kUO-SiZtFuz5cZCmMLnJJ9tjQ4-Zd_foo6R8HQMlM5A,1950
 fabricatio/models/events.py,sha256=wiirk_ASg3iXDOZU_gIimci1VZVzWE1nDmxy-hQVJ9M,4150
 fabricatio/models/extra/advanced_judge.py,sha256=INUl_41C8jkausDekkjnEmTwNfLCJ23TwFjq2cM23Cw,1092
+fabricatio/models/extra/aricle_rag.py,sha256=I65Dcip3iibQdkACPF-EgYv7bSlpXB9oj8eq-R-Tjdc,4681
 fabricatio/models/extra/article_base.py,sha256=DxBex4UsMAFmHmriwXkcvGIuU-WTSD4ZfzDEk-no9TA,11894
-fabricatio/models/extra/article_essence.py,sha256=xd6j-PDqjhrMjgUmyfk6HqkyMLu-sS9feUo0sZ3QABY,2825
+fabricatio/models/extra/article_essence.py,sha256=mlIkkRMR3I1RtqiiOnmIE3Vy623L4eECumkRzryE1pw,2749
 fabricatio/models/extra/article_main.py,sha256=zGzcf51abcWwiaX6iyi2V7upBLa-DBovnpTJj-qYLeA,7878
 fabricatio/models/extra/article_outline.py,sha256=w7O0SHgC7exbptWVbR62FMHAueMgBpyWKVYMGGl_oj8,1427
 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=zZEnjBW2XGRVpJpUp09f1J_w5A1zU-LhxX78AVCq9ts,7113
-fabricatio/models/extra/rag.py,sha256=_atfPwk3nzhiilAOC5H1WMBgTxcZvDn3qx0CVhETlZ8,2561
+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=BS-K8Rd_1aLU9jIExtXScvzNZ-lsBCmHlaBCjNJ6g3s,30655
-fabricatio/models/kwargs_types.py,sha256=J4klrMVybkCWg8Fq4x27o5QSq8jmGg2XvneW66jI0Wc,4565
+fabricatio/models/generic.py,sha256=M6K4uMSy4zKoTX5LyZFB8vXw8dTR9nZqec84eE-vPfw,30643
+fabricatio/models/kwargs_types.py,sha256=r0fgI4ExuAc0MMsgWs8fAyaQ9Z_PRRAKTr53pPP5JYY,4747
 fabricatio/models/role.py,sha256=-CRcj5_M3_ciLPzwiNn92grBmwoSLQ-n4koVZiCNTBM,2953
 fabricatio/models/task.py,sha256=SxWI-b5jlQcGmNsjQ2aKDyywXwGiUvCR1rgUhk-pli8,10503
 fabricatio/models/tool.py,sha256=jQ51g4lwTPfsMF1nbreDJtBczbxIHoXcPuLSOqHliq8,12506
 fabricatio/models/usages.py,sha256=VLBpNs7zfNPqROvI2IXlqsoqKYSW8L6usNwZ1HXZVOY,34339
 fabricatio/parser.py,sha256=qN2godNsArmb90btOMxgqlol57166DyYsV2JlU8DlHs,6532
 fabricatio/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-fabricatio/rust.pyi,sha256=vSItFXKj7YG6b7gmObMo99rWztsiYj4Ji124UNJbhd0,6957
+fabricatio/rust.pyi,sha256=uVHcjDkG4gPcWX_7pxJXHroamY6Db46tQci96THbwJs,7280
 fabricatio/rust_instances.py,sha256=Byeo8KHW_dJiXujJq7YPGDLBX5bHNDYbBc4sY3uubVY,313
 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=uy-W5b1d8oM1UTk2IT1lLGKIn_Pmo3XU5xbahjyDESE,1710
+fabricatio/utils.py,sha256=PKb2yfAe7iRwGJklLB5uZWuWhT0Tm47iHAqPo-zl5CQ,2039
 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=Rmvq2VgdS2u68vnOi2i5RbeWbAwrJDbk8D8D883PJWE,1022
-fabricatio/rust.cp312-win_amd64.pyd,sha256=pgavk4szzu7Fdb8oC-IK3XmhB9upqwxJxkMG_Ep65eQ,2235904
-fabricatio-0.2.10.dev0.data/scripts/tdown.exe,sha256=hH6MCz4SZWxYNzpNzlZ3KzTM2-H_wFyxMrKie4K24Go,3364864
-fabricatio-0.2.10.dev0.dist-info/RECORD,,
+fabricatio/rust.cp312-win_amd64.pyd,sha256=ql93jn1qacym6Ks927dxEGJb16rUyWPiW85fm9IE8A0,2251776
+fabricatio-0.2.10.dev1.data/scripts/tdown.exe,sha256=WFQ7z3utWNkccmrzZPzJTb4N0_IBWrjirdWSOKcrj_0,3365888
+fabricatio-0.2.10.dev1.dist-info/RECORD,,