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

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,110 @@ 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)  # noqa: RUF001
+
+    @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."""
+        matches = re.findall(self.pat, string)
+
+        for m in matches:
+            notations = self.convert_to_numeric_notations(m)
+
+            citation_number_seq = list(flatten(self.decode_expr(n) for n in notations))
+            dedup = self.deduplicate_citation(citation_number_seq)
+            string.replace(m, 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.cite_number)
+        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,7 +15,7 @@ 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 fabricatio.rust import convert_all_block_tex, convert_all_inline_tex, word_count
 from pydantic import Field
 
 PARAGRAPH_SEP = "// - - -"
@@ -153,6 +154,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 +225,20 @@ 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]`?."
+    )
+    def edit_titles(self) -> Self:
+        for a in self.iter_dfs():
+            pass

fabricatio/models/extra/problem.py

@@ -3,12 +3,12 @@
 from itertools import chain
 from typing import Any, List, Optional, Self, Tuple, Unpack
 
+from pydantic import Field
+from rich import print as r_print
+
 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
 
 
 class Problem(SketchedAble, WithBriefing):
@@ -74,6 +74,8 @@ class ProblemSolutions(SketchedAble):
         return len(self.solutions) > 0
 
     async def edit_problem(self) -> Self:
+        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,16 +3,10 @@
 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
-from fabricatio.config import configs
-from fabricatio.fs.readers import MAGIKA, safe_text_read
-from fabricatio.journal import logger
-from fabricatio.parser import JsonCapture
+import ujson
 from fabricatio.rust import blake3_hash, detect_language
-from fabricatio.rust_instances import TEMPLATE_MANAGER
-from fabricatio.utils import ok
 from litellm.utils import token_counter
 from pydantic import (
     BaseModel,
@@ -27,6 +21,13 @@ from pydantic import (
 )
 from pydantic.json_schema import GenerateJsonSchema, JsonSchemaValue
 
+from fabricatio.config import configs
+from fabricatio.fs.readers import safe_text_read
+from fabricatio.journal import logger
+from fabricatio.parser import JsonCapture
+from fabricatio.rust_instances import TEMPLATE_MANAGER
+from fabricatio.utils import ok
+
 
 class Base(BaseModel):
     """Base class for all models with Pydantic configuration.
@@ -74,9 +75,9 @@ class Display(Base):
             str: Combined display output with boundary markers
         """
         return (
-            "--- Start of Extra Info Sequence ---"
-            + "\n".join(d.compact() if compact else d.display() for d in seq)
-            + "--- End of Extra Info Sequence ---"
+                "--- Start of Extra Info Sequence ---"
+                + "\n".join(d.compact() if compact else d.display() for d in seq)
+                + "--- End of Extra Info Sequence ---"
         )
 
 
@@ -117,6 +118,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.
 
@@ -169,11 +179,17 @@ class WithRef[T](Base):
         )
 
     @overload
-    def update_ref[S: WithRef](self: S, reference: T) -> S: ...
+    def update_ref[S: WithRef](self: S, reference: T) -> S:
+        ...
+
     @overload
-    def update_ref[S: WithRef](self: S, reference: "WithRef[T]") -> S: ...
+    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: 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,9 +471,9 @@ class WithFormatedJsonSchema(Base):
         Returns:
             str: The JSON schema of the model in a formatted string.
         """
-        return orjson.dumps(
+        return ujson.dumps(
             cls.model_json_schema(schema_generator=UnsortGenerate),
-            option=orjson.OPT_INDENT_2,
+            option=ujson.OPT_INDENT_2,
         ).decode()
 
 
@@ -470,9 +486,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 +657,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 +754,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."""
 
@@ -858,13 +884,14 @@ class Patch[T](ProposedAble):
             # copy the desc info of each corresponding fields from `ref_cls`
             for field_name in [f for f in cls.model_fields if f in ref_cls.model_fields]:
                 my_schema["properties"][field_name]["description"] = (
-                    ref_cls.model_fields[field_name].description or my_schema["properties"][field_name]["description"]
+                        ref_cls.model_fields[field_name].description or my_schema["properties"][field_name][
+                    "description"]
                 )
             my_schema["description"] = ref_cls.__doc__
 
-        return orjson.dumps(
+        return ujson.dumps(
             my_schema,
-            option=orjson.OPT_INDENT_2,
+            option=ujson.OPT_INDENT_2,
         ).decode()
 
 

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
 

fabricatio/parser.py

@@ -1,12 +1,13 @@
 """A module to parse text using regular expressions."""
 
+import re
+from functools import lru_cache
+from re import Pattern, compile
 from typing import Any, Callable, Iterable, List, Optional, Self, Tuple, Type
 
-import orjson
-import regex
+import ujson
 from json_repair import repair_json
 from pydantic import BaseModel, ConfigDict, Field, PositiveInt, PrivateAttr, ValidationError
-from regex import Pattern, compile
 
 from fabricatio.config import configs
 from fabricatio.journal import logger
@@ -25,7 +26,7 @@ class Capture(BaseModel):
     """The target groups to capture from the pattern."""
     pattern: str = Field(frozen=True)
     """The regular expression pattern to search for."""
-    flags: PositiveInt = Field(default=regex.DOTALL | regex.MULTILINE | regex.IGNORECASE, frozen=True)
+    flags: PositiveInt = Field(default=re.DOTALL | re.MULTILINE | re.IGNORECASE, frozen=True)
     """The flags to use when compiling the regular expression pattern."""
     capture_type: Optional[str] = None
     """The type of capture to perform, e.g., 'json', which is used to dispatch the fixer accordingly."""
@@ -49,7 +50,8 @@ class Capture(BaseModel):
                 logger.debug("Applying json repair to text.")
                 if isinstance(text, str):
                     return repair_json(text, ensure_ascii=False)  # pyright: ignore [reportReturnType]
-                return [repair_json(item, ensure_ascii=False) for item in text]  # pyright: ignore [reportReturnType, reportGeneralTypeIssues]
+                return [repair_json(item, ensure_ascii=False) for item in
+                        text]  # pyright: ignore [reportReturnType, reportGeneralTypeIssues]
             case _:
                 return text  # pyright: ignore [reportReturnType]
 
@@ -63,7 +65,7 @@ class Capture(BaseModel):
             str | None: The captured text if the pattern is found, otherwise None.
 
         """
-        if (match :=self._compiled.match(text) or self._compiled.search(text) ) is None:
+        if (match := self._compiled.match(text) or self._compiled.search(text)) is None:
             logger.debug(f"Capture Failed {type(text)}: \n{text}")
             return None
         groups = self.fix(match.groups())
@@ -94,12 +96,12 @@ class Capture(BaseModel):
             return None
 
     def validate_with[K, T, E](
-        self,
-        text: str,
-        target_type: Type[T],
-        elements_type: Optional[Type[E]] = None,
-        length: Optional[int] = None,
-        deserializer: Callable[[Tuple[str, ...]], K] | Callable[[str], K] = orjson.loads,
+            self,
+            text: str,
+            target_type: Type[T],
+            elements_type: Optional[Type[E]] = None,
+            length: Optional[int] = None,
+            deserializer: Callable[[Tuple[str, ...]], K] | Callable[[str], K] = ujson.loads,
     ) -> T | None:
         """Validate the given text using the pattern.
 
@@ -124,6 +126,7 @@ class Capture(BaseModel):
         return None
 
     @classmethod
+    @lru_cache(32)
     def capture_code_block(cls, language: str) -> Self:
         """Capture the first occurrence of a code block in the given text.
 
@@ -136,6 +139,7 @@ class Capture(BaseModel):
         return cls(pattern=f"```{language}(.*?)```", capture_type=language)
 
     @classmethod
+    @lru_cache(32)
     def capture_generic_block(cls, language: str) -> Self:
         """Capture the first occurrence of a generic code block in the given text.