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

fabricatio/models/task.py

@@ -4,17 +4,16 @@ It includes methods to manage the task's lifecycle, such as starting, finishing,
 """
 
 from asyncio import Queue
-from typing import Any, Dict, List, Optional, Self
+from typing import Any, Dict, List, Optional, Self, Union
 
-from fabricatio.config import configs
-from fabricatio.constants import TaskStatus
-from fabricatio.core import env
+from fabricatio.emitter import env
 from fabricatio.journal import logger
-from fabricatio.models.events import Event, EventLike
 from fabricatio.models.generic import ProposedAble, WithBriefing, WithDependency
-from fabricatio.rust_instances import TEMPLATE_MANAGER
+from fabricatio.rust import CONFIG, TEMPLATE_MANAGER, Event, TaskStatus
 from pydantic import Field, PrivateAttr
 
+type EventLike = Union[str, Event, List[str]]
+
 
 class Task[T](WithBriefing, ProposedAble, WithDependency):
     """A class representing a task with a status and output.
@@ -33,7 +32,7 @@ class Task[T](WithBriefing, ProposedAble, WithDependency):
     description: str = Field(default="")
     """A detailed explanation of the task that includes all necessary information. Should be clear and answer what, why, when, where, who, and how questions."""
 
-    goals: List[str] = Field(default=[])
+    goals: List[str] = Field(default_factory=list)
     """A list of objectives that the task aims to accomplish. Each goal should be clear and specific. Complex tasks should be broken into multiple smaller goals."""
 
     namespace: List[str] = Field(default_factory=list)
@@ -65,7 +64,7 @@ class Task[T](WithBriefing, ProposedAble, WithDependency):
 
     def model_post_init(self, __context: Any) -> None:
         """Initialize the task with a namespace event."""
-        self._namespace.segments.extend(self.namespace)
+        self._namespace.concat(self.namespace)
 
     def move_to(self, new_namespace: EventLike) -> Self:
         """Move the task to a new namespace.
@@ -266,7 +265,7 @@ class Task[T](WithBriefing, ProposedAble, WithDependency):
             str: The briefing of the task.
         """
         return TEMPLATE_MANAGER.render_template(
-            configs.templates.task_briefing_template,
+            CONFIG.templates.task_briefing_template,
             self.model_dump(),
         )
 

fabricatio/models/tool.py

@@ -10,11 +10,11 @@ from inspect import iscoroutinefunction, signature
 from types import CodeType, ModuleType
 from typing import Any, Callable, Dict, List, Optional, Self, cast, overload
 
-from fabricatio.config import configs
 from fabricatio.decorators import logging_execution_info, use_temp_module
 from fabricatio.journal import logger
-from fabricatio.models.generic import WithBriefing
-from pydantic import BaseModel, ConfigDict, Field
+from fabricatio.models.generic import Base, WithBriefing
+from fabricatio.rust import CONFIG
+from pydantic import Field
 
 
 class Tool[**P, R](WithBriefing):
@@ -181,7 +181,7 @@ class ToolBox(WithBriefing):
         return hash(self.briefing)
 
 
-class ToolExecutor(BaseModel):
+class ToolExecutor(Base):
     """A class representing a tool executor with a sequence of tools to execute.
 
     This class manages a sequence of tools and provides methods to inject tools and data into a module, execute the tools,
@@ -191,7 +191,7 @@ class ToolExecutor(BaseModel):
         candidates (List[Tool]): The sequence of tools to execute.
         data (Dict[str, Any]): The data that could be used when invoking the tools.
     """
-    model_config = ConfigDict(use_attribute_docstrings=True)
+
     candidates: List[Tool] = Field(default_factory=list, frozen=True)
     """The sequence of tools to execute."""
 
@@ -210,7 +210,7 @@ class ToolExecutor(BaseModel):
             M: The module with injected tools.
         """
         module = module or cast(
-            "M", module_from_spec(spec=ModuleSpec(name=configs.toolbox.tool_module_name, loader=None))
+            "M", module_from_spec(spec=ModuleSpec(name=CONFIG.toolbox.tool_module_name, loader=None))
         )
         for tool in self.candidates:
             logger.debug(f"Injecting tool: {tool.name}")
@@ -229,7 +229,7 @@ class ToolExecutor(BaseModel):
             M: The module with injected data.
         """
         module = module or cast(
-            'M', module_from_spec(spec=ModuleSpec(name=configs.toolbox.data_module_name, loader=None))
+            "M", module_from_spec(spec=ModuleSpec(name=CONFIG.toolbox.data_module_name, loader=None))
         )
         for key, value in self.data.items():
             logger.debug(f"Injecting data: {key}")

fabricatio/models/usages.py

@@ -1,22 +1,25 @@
 """This module contains classes that manage the usage of language models and tools in tasks."""
 
 import traceback
+from abc import ABC
 from asyncio import gather
 from typing import Callable, Dict, Iterable, List, Literal, Optional, Self, Sequence, Set, Union, Unpack, overload
 
 import asyncstdlib
-import litellm
-from fabricatio.config import configs
 from fabricatio.decorators import logging_exec_time
 from fabricatio.journal import logger
 from fabricatio.models.generic import ScopedConfig, WithBriefing
 from fabricatio.models.kwargs_types import ChooseKwargs, EmbeddingKwargs, GenerateKwargs, LLMKwargs, ValidateKwargs
 from fabricatio.models.task import Task
 from fabricatio.models.tool import Tool, ToolBox
-from fabricatio.parser import GenericCapture, JsonCapture
-from fabricatio.rust_instances import TEMPLATE_MANAGER
-from fabricatio.utils import ok
-from litellm import RateLimitError, Router, stream_chunk_builder  # pyright: ignore [reportPrivateImportUsage]
+from fabricatio.rust import CONFIG, TEMPLATE_MANAGER
+from fabricatio.utils import first_available, ok
+from litellm import (  # pyright: ignore [reportPrivateImportUsage]
+    RateLimitError,
+    Router,
+    aembedding,
+    stream_chunk_builder,
+)
 from litellm.types.router import Deployment, LiteLLM_Params, ModelInfo
 from litellm.types.utils import (
     Choices,
@@ -29,22 +32,16 @@ from litellm.utils import CustomStreamWrapper, token_counter  # pyright: ignore
 from more_itertools import duplicates_everseen
 from pydantic import BaseModel, ConfigDict, Field, NonNegativeInt, PositiveInt
 
-if configs.cache.enabled and configs.cache.type:
-    litellm.enable_cache(type=configs.cache.type, **configs.cache.params)
-    logger.debug(f"{configs.cache.type.name} Cache enabled")
-
 ROUTER = Router(
     routing_strategy="usage-based-routing-v2",
-    default_max_parallel_requests=configs.routing.max_parallel_requests,
-    allowed_fails=configs.routing.allowed_fails,
-    retry_after=configs.routing.retry_after,
-    cooldown_time=configs.routing.cooldown_time,
-    cache_responses=configs.cache.enabled,
-    cache_kwargs=configs.cache.params,
+    default_max_parallel_requests=CONFIG.routing.max_parallel_requests,
+    allowed_fails=CONFIG.routing.allowed_fails,
+    retry_after=CONFIG.routing.retry_after,
+    cooldown_time=CONFIG.routing.cooldown_time,
 )
 
 
-class LLMUsage(ScopedConfig):
+class LLMUsage(ScopedConfig, ABC):
     """Class that manages LLM (Large Language Model) usage parameters and methods.
 
     This class provides methods to deploy LLMs, query them for responses, and handle various configurations
@@ -86,48 +83,48 @@ class LLMUsage(ScopedConfig):
             Deployment(
                 model_name=(
                     m_name := ok(
-                        kwargs.get("model") or self.llm_model or configs.llm.model, "model name is not set at any place"
+                        kwargs.get("model") or self.llm_model or CONFIG.llm.model, "model name is not set at any place"
                     )
                 ),  # pyright: ignore [reportCallIssue]
                 litellm_params=(
                     p := LiteLLM_Params(
                         api_key=ok(
-                            self.llm_api_key or configs.llm.api_key, "llm api key is not set at any place"
+                            self.llm_api_key or CONFIG.llm.api_key, "llm api key is not set at any place"
                         ).get_secret_value(),
                         api_base=ok(
-                            self.llm_api_endpoint or configs.llm.api_endpoint,
+                            self.llm_api_endpoint or CONFIG.llm.api_endpoint,
                             "llm api endpoint is not set at any place",
-                        ).unicode_string(),
+                        ),
                         model=m_name,
-                        tpm=self.llm_tpm or configs.llm.tpm,
-                        rpm=self.llm_rpm or configs.llm.rpm,
-                        max_retries=kwargs.get("max_retries") or self.llm_max_retries or configs.llm.max_retries,
-                        timeout=kwargs.get("timeout") or self.llm_timeout or configs.llm.timeout,
+                        tpm=self.llm_tpm or CONFIG.llm.tpm,
+                        rpm=self.llm_rpm or CONFIG.llm.rpm,
+                        max_retries=kwargs.get("max_retries") or self.llm_max_retries or CONFIG.llm.max_retries,
+                        timeout=kwargs.get("timeout") or self.llm_timeout or CONFIG.llm.timeout,
                     )
                 ),
                 model_info=ModelInfo(id=hash(m_name + p.model_dump_json(exclude_none=True))),
             )
         ).acompletion(
             messages=messages,  # pyright: ignore [reportArgumentType]
-            n=n or self.llm_generation_count or configs.llm.generation_count,
+            n=n or self.llm_generation_count or CONFIG.llm.generation_count,
             model=m_name,
-            temperature=kwargs.get("temperature") or self.llm_temperature or configs.llm.temperature,
-            stop=kwargs.get("stop") or self.llm_stop_sign or configs.llm.stop_sign,
-            top_p=kwargs.get("top_p") or self.llm_top_p or configs.llm.top_p,
-            max_tokens=kwargs.get("max_tokens") or self.llm_max_tokens or configs.llm.max_tokens,
-            stream=ok(kwargs.get("stream") or self.llm_stream or configs.llm.stream, "stream is not set at any place"),
+            temperature=kwargs.get("temperature") or self.llm_temperature or CONFIG.llm.temperature,
+            stop=kwargs.get("stop") or self.llm_stop_sign or CONFIG.llm.stop_sign,
+            top_p=kwargs.get("top_p") or self.llm_top_p or CONFIG.llm.top_p,
+            max_tokens=kwargs.get("max_tokens") or self.llm_max_tokens or CONFIG.llm.max_tokens,
+            stream=first_available(
+                (kwargs.get("stream"), self.llm_stream, CONFIG.llm.stream), "stream is not set at any place"
+            ),
             cache={
                 "no-cache": kwargs.get("no_cache"),
                 "no-store": kwargs.get("no_store"),
                 "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,
+            presence_penalty=kwargs.get("presence_penalty") or self.llm_presence_penalty or CONFIG.llm.presence_penalty,
             frequency_penalty=kwargs.get("frequency_penalty")
             or self.llm_frequency_penalty
-            or configs.llm.frequency_penalty,
+            or CONFIG.llm.frequency_penalty,
         )
 
     async def ainvoke(
@@ -155,11 +152,8 @@ class LLMUsage(ScopedConfig):
         )
         if isinstance(resp, ModelResponse):
             return resp.choices
-        if isinstance(resp, CustomStreamWrapper):
-            if not configs.debug.streaming_visible and (pack := stream_chunk_builder(await asyncstdlib.list())):
-                return pack.choices
-            if pack := stream_chunk_builder(await asyncstdlib.list(resp)):
-                return pack.choices
+        if isinstance(resp, CustomStreamWrapper) and (pack := stream_chunk_builder(await asyncstdlib.list(resp))):
+            return pack.choices
         logger.critical(err := f"Unexpected response type: {type(resp)}")
         raise ValueError(err)
 
@@ -170,6 +164,7 @@ class LLMUsage(ScopedConfig):
         system_message: List[str],
         **kwargs: Unpack[LLMKwargs],
     ) -> List[str]: ...
+
     @overload
     async def aask(
         self,
@@ -177,6 +172,7 @@ class LLMUsage(ScopedConfig):
         system_message: List[str],
         **kwargs: Unpack[LLMKwargs],
     ) -> List[str]: ...
+
     @overload
     async def aask(
         self,
@@ -231,7 +227,8 @@ class LLMUsage(ScopedConfig):
                 raise RuntimeError("Should not reach here.")
 
         logger.debug(
-            f"Response Token Count: {token_counter(text=out) if isinstance(out, str) else sum(token_counter(text=o) for o in out)}"  # pyright: ignore [reportOptionalIterable]
+            f"Response Token Count: {token_counter(text=out) if isinstance(out, str) else sum(token_counter(text=o) for o in out)}"
+            # pyright: ignore [reportOptionalIterable]
         )
         return out  # pyright: ignore [reportReturnType]
 
@@ -244,6 +241,7 @@ class LLMUsage(ScopedConfig):
         max_validations: PositiveInt = 2,
         **kwargs: Unpack[GenerateKwargs],
     ) -> T: ...
+
     @overload
     async def aask_validate[T](
         self,
@@ -253,6 +251,7 @@ class LLMUsage(ScopedConfig):
         max_validations: PositiveInt = 2,
         **kwargs: Unpack[GenerateKwargs],
     ) -> List[T]: ...
+
     @overload
     async def aask_validate[T](
         self,
@@ -331,9 +330,11 @@ class LLMUsage(ScopedConfig):
         Returns:
             Optional[List[str]]: The validated response as a list of strings.
         """
+        from fabricatio.parser import JsonCapture
+
         return await self.aask_validate(
             TEMPLATE_MANAGER.render_template(
-                configs.templates.liststr_template,
+                CONFIG.templates.liststr_template,
                 {"requirement": requirement, "k": k},
             ),
             lambda resp: JsonCapture.validate_with(resp, target_type=list, elements_type=str, length=k),
@@ -352,7 +353,7 @@ class LLMUsage(ScopedConfig):
         """
         return await self.alist_str(
             TEMPLATE_MANAGER.render_template(
-                configs.templates.pathstr_template,
+                CONFIG.templates.pathstr_template,
                 {"requirement": requirement},
             ),
             **kwargs,
@@ -387,9 +388,11 @@ class LLMUsage(ScopedConfig):
         Returns:
             Optional[str]: The generated string.
         """
+        from fabricatio.parser import GenericCapture
+
         return await self.aask_validate(  # pyright: ignore [reportReturnType]
             TEMPLATE_MANAGER.render_template(
-                configs.templates.generic_string_template,
+                CONFIG.templates.generic_string_template,
                 {"requirement": requirement, "language": GenericCapture.capture_type},
             ),
             validator=lambda resp: GenericCapture.capture(resp),
@@ -414,11 +417,13 @@ class LLMUsage(ScopedConfig):
         Returns:
             Optional[List[T]]: The final validated selection result list, with element types matching the input `choices`.
         """
+        from fabricatio.parser import JsonCapture
+
         if dup := duplicates_everseen(choices, key=lambda x: x.name):
             logger.error(err := f"Redundant choices: {dup}")
             raise ValueError(err)
         prompt = TEMPLATE_MANAGER.render_template(
-            configs.templates.make_choice_template,
+            CONFIG.templates.make_choice_template,
             {
                 "instruction": instruction,
                 "options": [m.model_dump(include={"name", "briefing"}) for m in choices],
@@ -489,9 +494,11 @@ class LLMUsage(ScopedConfig):
         Returns:
             bool: The judgment result (True or False) based on the AI's response.
         """
+        from fabricatio.parser import JsonCapture
+
         return await self.aask_validate(
             question=TEMPLATE_MANAGER.render_template(
-                configs.templates.make_judgment_template,
+                CONFIG.templates.make_judgment_template,
                 {"prompt": prompt, "affirm_case": affirm_case, "deny_case": deny_case},
             ),
             validator=lambda resp: JsonCapture.validate_with(resp, target_type=bool),
@@ -499,7 +506,7 @@ class LLMUsage(ScopedConfig):
         )
 
 
-class EmbeddingUsage(LLMUsage):
+class EmbeddingUsage(LLMUsage, ABC):
     """A class representing the embedding model.
 
     This class extends LLMUsage and provides methods to generate embeddings for input text using various models.
@@ -526,37 +533,36 @@ class EmbeddingUsage(LLMUsage):
             EmbeddingResponse: The response containing the embeddings.
         """
         # check seq length
-        max_len = self.embedding_max_sequence_length or configs.embedding.max_sequence_length
+        max_len = self.embedding_max_sequence_length or CONFIG.embedding.max_sequence_length
         if max_len and any(length := (token_counter(text=t)) > max_len for t in input_text):
             logger.error(err := f"Input text exceeds maximum sequence length {max_len}, got {length}.")
             raise ValueError(err)
 
-        return await litellm.aembedding(
+        return await aembedding(
             input=input_text,
-            caching=caching or self.embedding_caching or configs.embedding.caching,
-            dimensions=dimensions or self.embedding_dimensions or configs.embedding.dimensions,
-            model=model or self.embedding_model or configs.embedding.model or self.llm_model or configs.llm.model,
+            caching=caching or self.embedding_caching or CONFIG.embedding.caching,
+            dimensions=dimensions or self.embedding_dimensions or CONFIG.embedding.dimensions,
+            model=model or self.embedding_model or CONFIG.embedding.model or self.llm_model or CONFIG.llm.model,
             timeout=timeout
             or self.embedding_timeout
-            or configs.embedding.timeout
+            or CONFIG.embedding.timeout
             or self.llm_timeout
-            or configs.llm.timeout,
+            or CONFIG.llm.timeout,
             api_key=ok(
-                self.embedding_api_key or configs.embedding.api_key or self.llm_api_key or configs.llm.api_key
+                self.embedding_api_key or CONFIG.embedding.api_key or self.llm_api_key or CONFIG.llm.api_key
             ).get_secret_value(),
             api_base=ok(
                 self.embedding_api_endpoint
-                or configs.embedding.api_endpoint
+                or CONFIG.embedding.api_endpoint
                 or self.llm_api_endpoint
-                or configs.llm.api_endpoint
-            )
-            .unicode_string()
-            .rstrip("/"),
+                or CONFIG.llm.api_endpoint
+            ).rstrip("/"),
             # seems embedding function takes no base_url end with a slash
         )
 
     @overload
     async def vectorize(self, input_text: List[str], **kwargs: Unpack[EmbeddingKwargs]) -> List[List[float]]: ...
+
     @overload
     async def vectorize(self, input_text: str, **kwargs: Unpack[EmbeddingKwargs]) -> List[float]: ...
 
@@ -578,7 +584,7 @@ class EmbeddingUsage(LLMUsage):
         return [o.get("embedding") for o in (await self.aembedding(input_text, **kwargs)).data]
 
 
-class ToolBoxUsage(LLMUsage):
+class ToolBoxUsage(LLMUsage, ABC):
     """A class representing the usage of tools in a task.
 
     This class extends LLMUsage and provides methods to manage and use toolboxes and tools within tasks.

fabricatio/parser.py

@@ -1,152 +1,112 @@
-"""A module to parse text using regular expressions."""
+"""A module for capturing patterns in text using regular expressions."""
 
 import re
+from dataclasses import dataclass, field
 from functools import lru_cache
-from re import Pattern, compile
-from typing import Any, Callable, Iterable, List, Optional, Self, Tuple, Type
+from typing import Any, Callable, Iterable, List, Optional, Self, Tuple, Type, Union
 
 import ujson
 from json_repair import repair_json
-from pydantic import BaseModel, ConfigDict, Field, PositiveInt, PrivateAttr, ValidationError
 
-from fabricatio.config import configs
 from fabricatio.journal import logger
+from fabricatio.rust import CONFIG
 
 
-class Capture(BaseModel):
+@dataclass(frozen=True)
+class Capture:
     """A class to capture patterns in text using regular expressions.
 
     Attributes:
-        pattern (str): The regular expression pattern to search for.
-        _compiled (Pattern): The compiled regular expression pattern.
+        target_groups (Tuple[int, ...]): The target groups to extract from the match.
+        pattern (str): The regex pattern to search for.
+        flags (int): Flags to apply when compiling the regex.
+        capture_type (Optional[str]): Optional hint for post-processing (e.g., 'json').
     """
 
-    model_config = ConfigDict(use_attribute_docstrings=True)
-    target_groups: Tuple[int, ...] = Field(default_factory=tuple)
-    """The target groups to capture from the pattern."""
-    pattern: str = Field(frozen=True)
+    pattern: str = field()
     """The regular expression pattern to search for."""
-    flags: PositiveInt = Field(default=re.DOTALL | re.MULTILINE | re.IGNORECASE, frozen=True)
-    """The flags to use when compiling the regular expression pattern."""
+    flags: int = re.DOTALL | re.MULTILINE | re.IGNORECASE
+    """Flags to control regex behavior (DOTALL, MULTILINE, IGNORECASE by default)."""
     capture_type: Optional[str] = None
-    """The type of capture to perform, e.g., 'json', which is used to dispatch the fixer accordingly."""
-    _compiled: Pattern = PrivateAttr()
+    """Optional type identifier for post-processing (e.g., 'json' for JSON repair)."""
+    target_groups: Tuple[int, ...] = field(default_factory=tuple)
+    """Tuple of group indices to extract from the match (1-based indexing)."""
 
-    def model_post_init(self, __context: Any) -> None:
-        """Initialize the compiled pattern."""
-        self._compiled = compile(self.pattern, self.flags)
-
-    def fix[T](self, text: str | Iterable[str] | T) -> str | List[str] | T:
-        """Fix the text using the pattern.
-
-        Args:
-            text (str | List[str]): The text to fix.
-
-        Returns:
-            str | List[str]: The fixed text with the same type as input.
-        """
+    def fix(self, text: Union[str, Iterable[str], Any]) -> Union[str, List[str], Any]:
+        """Fix the text based on capture_type (e.g., JSON repair)."""
         match self.capture_type:
-            case "json" if configs.general.use_json_repair:
-                logger.debug("Applying json repair to text.")
+            case "json" if CONFIG.general.use_json_repair:
+                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(text, ensure_ascii=False)
+                return [repair_json(item, ensure_ascii=False) for item in text]
             case _:
-                return text  # pyright: ignore [reportReturnType]
-
-    def capture(self, text: str) -> Tuple[str, ...] | str | None:
-        """Capture the first occurrence of the pattern in the given text.
-
-        Args:
-            text (str): The text to search the pattern in.
-
-        Returns:
-            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:
-            logger.debug(f"Capture Failed {type(text)}: \n{text}")
+                return text
+
+    def capture(self, text: str) -> Optional[Union[str, Tuple[str, ...]]]:
+        """Capture the first match of the pattern in the text."""
+        compiled = re.compile(self.pattern, self.flags)
+        match = compiled.match(text) or compiled.search(text)
+        if match is None:
+            logger.debug(f"Capture Failed: {text}")
             return None
+
         groups = self.fix(match.groups())
         if self.target_groups:
             cap = tuple(groups[g - 1] for g in self.target_groups)
-            logger.debug(f"Captured text: {'\n\n'.join(cap)}")
+            logger.debug(f"Captured texts: {'\n==\n'.join(cap)}")
             return cap
         cap = groups[0]
         logger.debug(f"Captured text: \n{cap}")
         return cap
 
-    def convert_with[T](self, text: str, convertor: Callable[[Tuple[str, ...]], T] | Callable[[str], T]) -> T | None:
-        """Convert the given text using the pattern.
-
-        Args:
-            text (str): The text to search the pattern in.
-            convertor (Callable[[Tuple[str, ...]], T] | Callable[[str], T]): The function to convert the captured text.
-
-        Returns:
-            str | None: The converted text if the pattern is found, otherwise None.
-        """
+    def convert_with(
+        self,
+        text: str,
+        convertor: Callable[[Union[str, Tuple[str, ...]]], Any],
+    ) -> Optional[Any]:
+        """Convert captured text using a provided function."""
         if (cap := self.capture(text)) is None:
             return None
         try:
-            return convertor(cap)  # pyright: ignore [reportArgumentType]
-        except (ValueError, SyntaxError, ValidationError) as e:
-            logger.error(f"Failed to convert text using {convertor.__name__} to convert.\nerror: {e}\n {cap}")
+            return convertor(cap)
+        except Exception as e:  # noqa: BLE001
+            logger.error(f"Failed to convert text using {convertor.__name__}: {e}\n{cap}")
             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] = ujson.loads,
-    ) -> T | None:
-        """Validate the given text using the pattern.
-
-        Args:
-            text (str): The text to search the pattern in.
-            target_type (Type[T]): The expected type of the output, dict or list.
-            elements_type (Optional[Type[E]]): The expected type of the elements in the output dict keys or list elements.
-            length (Optional[int]): The expected length of the output, bool(length)==False means no length validation.
-            deserializer (Callable[[Tuple[str, ...]], K] | Callable[[str], K]): The function to deserialize the captured text.
-
-        Returns:
-            T | None: The validated text if the pattern is found and the output is of the expected type, otherwise None.
-        """
-        judges = [lambda output_obj: isinstance(output_obj, target_type)]
+    def validate_with[T, K, E](
+        self,
+        text: str,
+        target_type: Type[T],
+        elements_type: Optional[Type[E]] = None,
+        length: Optional[int] = None,
+        deserializer: Callable[[Union[str, Tuple[str, ...]]], K] = lambda x: ujson.loads(x) if isinstance(x, str) else ujson.loads(x[0]),
+    ) -> Optional[T]:
+        """Deserialize and validate the captured text against expected types."""
+        judges = [lambda obj: isinstance(obj, target_type)]
         if elements_type:
-            judges.append(lambda output_obj: all(isinstance(e, elements_type) for e in output_obj))
+            judges.append(lambda obj: all(isinstance(e, elements_type) for e in obj))
         if length:
-            judges.append(lambda output_obj: len(output_obj) == length)
+            judges.append(lambda obj: len(obj) == length)
 
         if (out := self.convert_with(text, deserializer)) and all(j(out) for j in judges):
-            return out  # pyright: ignore [reportReturnType]
+            return out  # type: ignore
         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.
-
-        Args:
-            language (str): The text containing the code block.
-
-        Returns:
-            Self: The instance of the class with the captured code block.
-        """
+        """Capture a code block of the given language."""
         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.
-
-        Returns:
-            Self: The instance of the class with the captured code block.
-        """
-        return cls(pattern=f"--- Start of {language} ---(.*?)--- end of {language} ---", capture_type=language)
+        """Capture a generic block of the given language."""
+        return cls(
+            pattern=f"--- Start of {language} ---(.*?)--- End of {language} ---",
+            capture_type=language,
+        )
 
 
 JsonCapture = Capture.capture_code_block("json")