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

fabricatio/decorators.py

@@ -8,14 +8,34 @@ from shutil import which
 from types import ModuleType
 from typing import Callable, List, Optional
 
-from questionary import confirm
-
 from fabricatio.config import configs
 from fabricatio.journal import logger
 
 
+def precheck_package[**P, R](package_name: str, msg: str) -> Callable[[Callable[P, R]], Callable[P, R]]:
+    """Check if a package exists in the current environment.
+
+    Args:
+        package_name (str): The name of the package to check.
+        msg (str): The message to display if the package is not found.
+
+    Returns:
+        bool: True if the package exists, False otherwise.
+    """
+
+    def _wrapper(func: Callable[P, R]) -> Callable[P, R]:
+        def _inner(*args: P.args, **kwargs: P.kwargs) -> R:
+            if find_spec(package_name):
+                return func(*args, **kwargs)
+            raise RuntimeError(msg)
+
+        return _inner
+
+    return _wrapper
+
+
 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.
 
@@ -68,6 +88,8 @@ def logging_execution_info[**P, R](func: Callable[P, R]) -> Callable[P, R]:
     return _wrapper
 
 
+@precheck_package("questionary",
+                  "'questionary' is required to run this function. Have you installed `fabricatio[qa]`?.")
 def confirm_to_execute[**P, R](func: Callable[P, R]) -> Callable[P, Optional[R]] | Callable[P, R]:
     """Decorator to confirm before executing a function.
 
@@ -80,14 +102,15 @@ def confirm_to_execute[**P, R](func: Callable[P, R]) -> Callable[P, Optional[R]]
     if not configs.general.confirm_on_ops:
         # Skip confirmation if the configuration is set to False
         return func
+    from questionary import confirm
 
     if iscoroutinefunction(func):
 
         @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.")
@@ -98,8 +121,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.")
@@ -192,7 +215,6 @@ def logging_exec_time[**P, R](func: Callable[P, R]) -> Callable[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()
@@ -210,25 +232,3 @@ def logging_exec_time[**P, R](func: Callable[P, R]) -> Callable[P, R]:
         return result
 
     return _wrapper
-
-
-def precheck_package[**P, R](package_name: str, msg: str) -> Callable[[Callable[P, R]], Callable[P, R]]:
-    """Check if a package exists in the current environment.
-
-    Args:
-        package_name (str): The name of the package to check.
-        msg (str): The message to display if the package is not found.
-
-    Returns:
-        bool: True if the package exists, False otherwise.
-    """
-
-    def _wrapper(func: Callable[P, R]) -> Callable[P, R]:
-        def _inner(*args: P.args, **kwargs: P.kwargs) -> R:
-            if find_spec(package_name):
-                return func(*args, **kwargs)
-            raise RuntimeError(msg)
-
-        return _inner
-
-    return _wrapper

fabricatio/fs/__init__.py

@@ -1,5 +1,7 @@
 """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,
@@ -11,10 +13,9 @@ from fabricatio.fs.curd import (
     move_file,
     tree,
 )
-from fabricatio.fs.readers import MAGIKA, safe_json_read, safe_text_read
+from fabricatio.fs.readers import safe_json_read, safe_text_read
 
 __all__ = [
-    "MAGIKA",
     "absolute_path",
     "copy_file",
     "create_directory",
@@ -27,3 +28,9 @@ __all__ = [
     "safe_text_read",
     "tree",
 ]
+
+if find_spec("magika"):
+    from magika import Magika
+
+    MAGIKA = Magika(model_dir=configs.magika.model_dir)
+    __all__ += ["MAGIKA"]

fabricatio/fs/readers.py

@@ -1,17 +1,13 @@
 """Filesystem readers for Fabricatio."""
 
+import re
 from pathlib import Path
 from typing import Dict, List, Tuple
 
-import orjson
-import regex
-from magika import Magika
+import ujson
 
-from fabricatio.config import configs
 from fabricatio.journal import logger
 
-MAGIKA = Magika(model_dir=configs.magika.model_dir)
-
 
 def safe_text_read(path: Path | str) -> str:
     """Safely read the text from a file.
@@ -41,8 +37,8 @@ def safe_json_read(path: Path | str) -> Dict:
     """
     path = Path(path)
     try:
-        return orjson.loads(path.read_text(encoding="utf-8"))
-    except (orjson.JSONDecodeError, IsADirectoryError, FileNotFoundError) as e:
+        return ujson.loads(path.read_text(encoding="utf-8"))
+    except (ujson.JSONDecodeError, IsADirectoryError, FileNotFoundError) as e:
         logger.error(f"Failed to read file {path}: {e!s}")
         return {}
 
@@ -58,8 +54,8 @@ def extract_sections(string: str, level: int, section_char: str = "#") -> List[T
     Returns:
         List[Tuple[str, str]]: List of (header_text, section_content) tuples
     """
-    return regex.findall(
+    return re.findall(
         r"^%s{%d}\s+(.+?)\n((?:(?!^%s{%d}\s).|\n)*)" % (section_char, level, section_char, level),
         string,
-        regex.MULTILINE,
+        re.MULTILINE,
     )

fabricatio/models/extra/aricle_rag.py

@@ -1,22 +1,27 @@
 """A Module containing the article rag models."""
 
+import re
 from pathlib import Path
-from typing import ClassVar, Dict, List, Self, Unpack
+from typing import ClassVar, Dict, List, Optional, 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 fabricatio.rust import BibManager, is_chinese, split_into_chunks
+from fabricatio.utils import ok
+from more_itertools.recipes import flatten, unique
 from pydantic import Field
 
 
 class ArticleChunk(MilvusDataBase, AsPrompt):
     """The chunk of an article."""
 
+    etc_word: ClassVar[str] = "等"
+    and_word: ClassVar[str] = "与"
+    _cite_number: Optional[int] = None
+
     head_split: ClassVar[List[str]] = [
         "引 言",
         "引言",
@@ -48,12 +53,14 @@ class ArticleChunk(MilvusDataBase, AsPrompt):
 
     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",
+            f"[[{ok(self._cite_number, 'You need to update cite number first.')}]] reference `{self.article_title}`": self.chunk
         }
 
+    @property
+    def cite_number(self) -> int:
+        """Get the cite number."""
+        return ok(self._cite_number, "cite number not set")
+
     def _prepare_vectorization_inner(self) -> str:
         return self.chunk
 
@@ -89,8 +96,9 @@ class ArticleChunk(MilvusDataBase, AsPrompt):
 
         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)
+            for c in split_into_chunks(cls.purge_numeric_citation(cls.strip(safe_text_read(path))), **kwargs)
         ]
+
         logger.debug(f"Number of chunks created from file {path.as_posix()}: {len(result)}")
         return result
 
@@ -118,3 +126,111 @@ class ArticleChunk(MilvusDataBase, AsPrompt):
             logger.warning("No decrease at tail strip, which is might be abnormal.")
 
         return string
+
+    def as_typst_cite(self) -> str:
+        """As typst cite."""
+        return f"#cite(<{self.bibtex_cite_key}>)"
+
+    @staticmethod
+    def purge_numeric_citation(string: str) -> str:
+        """Purge numeric citation."""
+        import re
+
+        return re.sub(r"\[[\d\s,\\~–-]+]", "", string)
+
+    @property
+    def auther_firstnames(self) -> List[str]:
+        """Get the first name of the authors."""
+        ret = []
+        for n in self.authors:
+            if is_chinese(n):
+                ret.append(n[0])
+            else:
+                ret.append(n.split()[-1])
+        return ret
+
+    def as_auther_seq(self) -> str:
+        """Get the auther sequence."""
+        match len(self.authors):
+            case 0:
+                raise ValueError("No authors found")
+            case 1:
+                return f"（{self.auther_firstnames[0]}，{self.year}）{self.as_typst_cite()}"
+            case 2:
+                return f"（{self.auther_firstnames[0]}{self.and_word}{self.auther_firstnames[1]}，{self.year}）{self.as_typst_cite()}"
+            case 3:
+                return f"（{self.auther_firstnames[0]}，{self.auther_firstnames[1]}{self.and_word}{self.auther_firstnames[2]}，{self.year}）{self.as_typst_cite()}"
+            case _:
+                return f"（{self.auther_firstnames[0]}，{self.auther_firstnames[1]}{self.and_word}{self.auther_firstnames[2]}{self.etc_word}，{self.year}）{self.as_typst_cite()}"
+
+    def update_cite_number(self, cite_number: int) -> Self:
+        """Update the cite number."""
+        self._cite_number = cite_number
+        return self
+
+
+class CitationManager(AsPrompt):
+    """Citation manager."""
+
+    article_chunks: List[ArticleChunk] = Field(default_factory=list)
+    """Article chunks."""
+
+    pat: str = r"(\[\[([\d\s,-]*)]])"
+    """Regex pattern to match citations."""
+    sep: str = ","
+    """Separator for citation numbers."""
+    abbr_sep: str = "-"
+    """Separator for abbreviated citation numbers."""
+
+    def update_chunks(self, article_chunks: List[ArticleChunk], set_cite_number: bool = True) -> Self:
+        """Update article chunks."""
+        self.article_chunks.clear()
+        self.article_chunks.extend(article_chunks)
+        if set_cite_number:
+            self.set_cite_number_all()
+        return self
+
+    def set_cite_number_all(self) -> Self:
+        """Set citation numbers for all article chunks."""
+        for i, a in enumerate(self.article_chunks, 1):
+            a.update_cite_number(i)
+        return self
+
+    def _as_prompt_inner(self) -> Dict[str, str]:
+        """Generate prompt inner representation."""
+        return {"References": "\n".join(r.as_prompt() for r in self.article_chunks)}
+
+    def apply(self, string: str) -> str:
+        """Apply citation replacements to the input string."""
+        for origin,m in re.findall(self.pat, string):
+            logger.info(f"Matching citation: {m}")
+            notations = self.convert_to_numeric_notations(m)
+            logger.info(f"Citing Notations: {notations}")
+            citation_number_seq = list(flatten(self.decode_expr(n) for n in notations))
+            logger.info(f"Citation Number Sequence: {citation_number_seq}")
+            dedup = self.deduplicate_citation(citation_number_seq)
+            logger.info(f"Deduplicated Citation Number Sequence: {dedup}")
+            string=string.replace(origin, self.unpack_cite_seq(dedup))
+        return string
+
+    def decode_expr(self, string: str) -> List[int]:
+        """Decode citation expression into a list of integers."""
+        if self.abbr_sep in string:
+            start, end = string.split(self.abbr_sep)
+            return list(range(int(start), int(end) + 1))
+        return [int(string)]
+
+    def convert_to_numeric_notations(self, string: str) -> List[str]:
+        """Convert citation string into numeric notations."""
+        return [s.strip() for s in string.split(self.sep)]
+
+    def deduplicate_citation(self, citation_seq: List[int]) -> List[int]:
+        """Deduplicate citation sequence."""
+        chunk_seq = [a for a in self.article_chunks if a.cite_number in citation_seq]
+        deduped = unique(chunk_seq, lambda a: a.bibtex_cite_key)
+        return [a.cite_number for a in deduped]
+
+    def unpack_cite_seq(self, citation_seq: List[int]) -> str:
+        """Unpack citation sequence into a string."""
+        chunk_seq = [a for a in self.article_chunks if a.cite_number in citation_seq]
+        return "".join(a.as_typst_cite() for a in chunk_seq)

fabricatio/models/extra/article_main.py

@@ -2,6 +2,7 @@
 
 from typing import Dict, Generator, List, Self, Tuple, override
 
+from fabricatio.decorators import precheck_package
 from fabricatio.fs.readers import extract_sections
 from fabricatio.journal import logger
 from fabricatio.models.extra.article_base import (
@@ -14,8 +15,8 @@ from fabricatio.models.extra.article_outline import (
     ArticleOutline,
 )
 from fabricatio.models.generic import Described, PersistentAble, SequencePatch, SketchedAble, WithRef, WordCount
-from fabricatio.rust import word_count
-from pydantic import Field
+from fabricatio.rust import convert_all_block_tex, convert_all_inline_tex, word_count
+from pydantic import Field, NonNegativeInt
 
 PARAGRAPH_SEP = "// - - -"
 
@@ -23,6 +24,9 @@ PARAGRAPH_SEP = "// - - -"
 class Paragraph(SketchedAble, WordCount, Described):
     """Structured academic paragraph blueprint for controlled content generation."""
 
+    expected_word_count: NonNegativeInt = 0
+    """The expected word count of this paragraph, 0 means not specified"""
+
     description: str = Field(
         alias="elaboration",
         description=Described.model_fields["description"].description,
@@ -153,6 +157,26 @@ class Article(
             "Original Article": self.display(),
         }
 
+    def convert_tex(self) -> Self:
+        """Convert tex to typst code."""
+        for _, _, subsec in self.iter_subsections():
+            for p in subsec.paragraphs:
+                p.content = convert_all_inline_tex(p.content)
+                p.content = convert_all_block_tex(p.content)
+        return self
+
+    def fix_wrapper(self) -> Self:
+        """Fix wrapper."""
+        for _, _, subsec in self.iter_subsections():
+            for p in subsec.paragraphs:
+                p.content = (
+                    p.content.replace(r" \( ", "$")
+                    .replace(r" \) ", "$")
+                    .replace("\\[\n", "$$\n")
+                    .replace("\n\\]", "\n$$")
+                )
+        return self
+
     @override
     def iter_subsections(self) -> Generator[Tuple[ArticleChapter, ArticleSection, ArticleSubsection], None, None]:
         return super().iter_subsections()  # pyright: ignore [reportReturnType]
@@ -204,3 +228,23 @@ class Article(
             expected_word_count=word_count(body),
             abstract="",
         )
+
+    @classmethod
+    def from_mixed_source(cls, article_outline: ArticleOutline, typst_code: str) -> Self:
+        """Generates an article from the given outline and Typst code."""
+        self = cls.from_typst_code(article_outline.title, typst_code)
+        self.expected_word_count = article_outline.expected_word_count
+        self.description = article_outline.description
+        for a, o in zip(self.iter_dfs(), article_outline.iter_dfs(), strict=True):
+            a.update_metadata(o)
+        return self.update_ref(article_outline)
+
+    @precheck_package(
+        "questionary", "'questionary' is required to run this function. Have you installed `fabricatio[qa]`?."
+    )
+    async def edit_titles(self) -> Self:
+        """Edits the titles of the article."""
+        from questionary import text
+
+        for a in self.iter_dfs():
+            a.title = await text(f"Edit `{a.title}`.", default=a.title).ask_async() or a.title

fabricatio/models/extra/problem.py

@@ -7,7 +7,6 @@ from fabricatio.journal import logger
 from fabricatio.models.generic import SketchedAble, WithBriefing
 from fabricatio.utils import ask_edit
 from pydantic import Field
-from questionary import Choice, checkbox, text
 from rich import print as r_print
 
 
@@ -74,6 +73,9 @@ class ProblemSolutions(SketchedAble):
         return len(self.solutions) > 0
 
     async def edit_problem(self) -> Self:
+        """Interactively edit the problem description."""
+        from questionary import text
+
         """Interactively edit the problem description."""
         self.problem = Problem.model_validate_strings(
             await text("Please edit the problem below:", default=self.problem.display()).ask_async()
@@ -127,6 +129,8 @@ class Improvement(SketchedAble):
         Returns:
             Self: The current instance with filtered problems and solutions.
         """
+        from questionary import Choice, checkbox
+
         # Choose the problems to retain
         chosen_ones: List[ProblemSolutions] = await checkbox(
             "Please choose the problems you want to retain.(Default: retain all)",

fabricatio/models/generic.py

@@ -3,11 +3,11 @@
 from abc import ABC, abstractmethod
 from datetime import datetime
 from pathlib import Path
-from typing import Any, Callable, Dict, Iterable, List, Optional, Self, Type, Union, final, overload
+from typing import Any, Callable, Dict, Iterable, List, Mapping, Optional, Self, Type, Union, final, overload
 
-import orjson
+import ujson
 from fabricatio.config import configs
-from fabricatio.fs.readers import MAGIKA, safe_text_read
+from fabricatio.fs.readers import safe_text_read
 from fabricatio.journal import logger
 from fabricatio.parser import JsonCapture
 from fabricatio.rust import blake3_hash, detect_language
@@ -117,6 +117,15 @@ class WordCount(Base):
     """Expected word count of this research component."""
 
 
+class FromMapping(Base):
+    """Class that provides a method to generate a list of objects from a mapping."""
+
+    @classmethod
+    @abstractmethod
+    def from_mapping(cls, mapping: Mapping[str, Any], **kwargs: Any) -> List[Self]:
+        """Generate a list of objects from a mapping."""
+
+
 class AsPrompt(Base):
     """Class that provides a method to generate a prompt from the model.
 
@@ -170,10 +179,13 @@ class WithRef[T](Base):
 
     @overload
     def update_ref[S: WithRef](self: S, reference: T) -> S: ...
+
     @overload
     def update_ref[S: WithRef](self: S, reference: "WithRef[T]") -> S: ...
+
     @overload
     def update_ref[S: WithRef](self: S, reference: None = None) -> S: ...
+
     def update_ref[S: WithRef](self: S, reference: Union[T, "WithRef[T]", None] = None) -> S:  # noqa: PYI019
         """Update the reference of the object.
 
@@ -455,10 +467,9 @@ class WithFormatedJsonSchema(Base):
         Returns:
             str: The JSON schema of the model in a formatted string.
         """
-        return orjson.dumps(
-            cls.model_json_schema(schema_generator=UnsortGenerate),
-            option=orjson.OPT_INDENT_2,
-        ).decode()
+        return ujson.dumps(
+            cls.model_json_schema(schema_generator=UnsortGenerate), indent=2, ensure_ascii=False, sort_keys=False
+        )
 
 
 class CreateJsonObjPrompt(WithFormatedJsonSchema):
@@ -470,9 +481,11 @@ class CreateJsonObjPrompt(WithFormatedJsonSchema):
     @classmethod
     @overload
     def create_json_prompt(cls, requirement: List[str]) -> List[str]: ...
+
     @classmethod
     @overload
     def create_json_prompt(cls, requirement: str) -> str: ...
+
     @classmethod
     def create_json_prompt(cls, requirement: str | List[str]) -> str | List[str]:
         """Create the prompt for creating a JSON object with given requirement.
@@ -639,6 +652,8 @@ class WithDependency(Base):
         Returns:
             str: The generated prompt for the task.
         """
+        from fabricatio.fs import MAGIKA
+
         return TEMPLATE_MANAGER.render_template(
             configs.templates.dependencies_template,
             {
@@ -734,6 +749,12 @@ class ScopedConfig(Base):
     llm_rpm: Optional[PositiveInt] = None
     """The requests per minute of the LLM model."""
 
+    llm_presence_penalty: Optional[PositiveFloat] = None
+    """The presence penalty of the LLM model."""
+
+    llm_frequency_penalty: Optional[PositiveFloat] = None
+    """The frequency penalty of the LLM model."""
+
     embedding_api_endpoint: Optional[HttpUrl] = None
     """The OpenAI API endpoint."""
 
@@ -862,10 +883,7 @@ class Patch[T](ProposedAble):
                 )
             my_schema["description"] = ref_cls.__doc__
 
-        return orjson.dumps(
-            my_schema,
-            option=orjson.OPT_INDENT_2,
-        ).decode()
+        return ujson.dumps(my_schema, indent=2, ensure_ascii=False, sort_keys=False)
 
 
 class SequencePatch[T](ProposedUpdateAble):

fabricatio/models/kwargs_types.py

@@ -45,6 +45,8 @@ class LLMKwargs(TypedDict, total=False):
     no_store: bool  # If store the response of this call to cache
     cache_ttl: int  # how long the stored cache is alive, in seconds
     s_maxage: int  # max accepted age of cached response, in seconds
+    presence_penalty: float
+    frequency_penalty: float
 
 
 class GenerateKwargs(LLMKwargs, total=False):
@@ -66,7 +68,7 @@ class ValidateKwargs[T](GenerateKwargs, total=False):
 
     default: Optional[T]
     max_validations: int
-    co_extractor: GenerateKwargs
+
 
 
 class CompositeScoreKwargs(ValidateKwargs[List[Dict[str, float]]], total=False):

fabricatio/models/usages.py

@@ -63,7 +63,7 @@ class LLMUsage(ScopedConfig):
         self._added_deployment = ROUTER.upsert_deployment(deployment)
         return ROUTER
 
-    # noinspection PyTypeChecker,PydanticTypeChecker
+    # noinspection PyTypeChecker,PydanticTypeChecker,t
     async def aquery(
         self,
         messages: List[Dict[str, str]],
@@ -122,6 +122,12 @@ class LLMUsage(ScopedConfig):
                 "cache-ttl": kwargs.get("cache_ttl"),
                 "s-maxage": kwargs.get("s_maxage"),
             },
+            presence_penalty=kwargs.get("presence_penalty")
+            or self.llm_presence_penalty
+            or configs.llm.presence_penalty,
+            frequency_penalty=kwargs.get("frequency_penalty")
+            or self.llm_frequency_penalty
+            or configs.llm.frequency_penalty,
         )
 
     async def ainvoke(
@@ -236,7 +242,6 @@ class LLMUsage(ScopedConfig):
         validator: Callable[[str], T | None],
         default: T = ...,
         max_validations: PositiveInt = 2,
-        co_extractor: Optional[GenerateKwargs] = None,
         **kwargs: Unpack[GenerateKwargs],
     ) -> T: ...
     @overload
@@ -246,7 +251,6 @@ class LLMUsage(ScopedConfig):
         validator: Callable[[str], T | None],
         default: T = ...,
         max_validations: PositiveInt = 2,
-        co_extractor: Optional[GenerateKwargs] = None,
         **kwargs: Unpack[GenerateKwargs],
     ) -> List[T]: ...
     @overload
@@ -256,7 +260,6 @@ class LLMUsage(ScopedConfig):
         validator: Callable[[str], T | None],
         default: None = None,
         max_validations: PositiveInt = 2,
-        co_extractor: Optional[GenerateKwargs] = None,
         **kwargs: Unpack[GenerateKwargs],
     ) -> Optional[T]: ...
 
@@ -267,7 +270,6 @@ class LLMUsage(ScopedConfig):
         validator: Callable[[str], T | None],
         default: None = None,
         max_validations: PositiveInt = 2,
-        co_extractor: Optional[GenerateKwargs] = None,
         **kwargs: Unpack[GenerateKwargs],
     ) -> List[Optional[T]]: ...
 
@@ -277,7 +279,6 @@ class LLMUsage(ScopedConfig):
         validator: Callable[[str], T | None],
         default: Optional[T] = None,
         max_validations: PositiveInt = 3,
-        co_extractor: Optional[GenerateKwargs] = None,
         **kwargs: Unpack[GenerateKwargs],
     ) -> Optional[T] | List[Optional[T]] | List[T] | T:
         """Asynchronously asks a question and validates the response using a given validator.
@@ -287,34 +288,16 @@ class LLMUsage(ScopedConfig):
             validator (Callable[[str], T | None]): A function to validate the response.
             default (T | None): Default value to return if validation fails. Defaults to None.
             max_validations (PositiveInt): Maximum number of validation attempts. Defaults to 3.
-            co_extractor (Optional[GenerateKwargs]): Keyword arguments for the co-extractor, if provided will enable co-extraction.
             **kwargs (Unpack[GenerateKwargs]): Additional keyword arguments for the LLM usage.
 
         Returns:
-            Optional[T] | List[Optional[T]] | List[T] | T: The validated response.
+            Optional[T] | List[T | None] | List[T] | T: The validated response.
         """
 
         async def _inner(q: str) -> Optional[T]:
             for lap in range(max_validations):
                 try:
-                    if ((validated := validator(response := await self.aask(question=q, **kwargs))) is not None) or (
-                        co_extractor is not None
-                        and logger.debug("Co-extraction is enabled.") is None
-                        and (
-                            validated := validator(
-                                response := await self.aask(
-                                    question=(
-                                        TEMPLATE_MANAGER.render_template(
-                                            configs.templates.co_validation_template,
-                                            {"original_q": q, "original_a": response},
-                                        )
-                                    ),
-                                    **co_extractor,
-                                )
-                            )
-                        )
-                        is not None
-                    ):
+                    if (validated := validator(response := await self.aask(question=q, **kwargs))) is not None:
                         logger.debug(f"Successfully validated the response at {lap}th attempt.")
                         return validated