fabricatio 0.2.1.dev0__cp313-cp313-win_amd64.whl → 0.3.14.dev4__cp313-cp313-win_amd64.whl

fabricatio/parser.py

@@ -1,93 +1,114 @@
-"""A module to parse text using regular expressions."""
+"""A module for capturing patterns in text using regular expressions."""
 
-from typing import Any, Callable, Self, Tuple
+import re
+from dataclasses import dataclass, field
+from functools import lru_cache
+from typing import Any, Callable, Iterable, List, Optional, Self, Tuple, Type, Union
 
-import regex
-from pydantic import BaseModel, ConfigDict, Field, PositiveInt, PrivateAttr
-from regex import Pattern, compile
+import ujson
+from json_repair import repair_json
 
 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=regex.DOTALL | regex.MULTILINE | regex.IGNORECASE, frozen=True)
-    """The flags to use when compiling the regular expression pattern."""
-    _compiled: Pattern = PrivateAttr()
-
-    def model_post_init(self, __context: Any) -> None:
-        """Initialize the compiled regular expression pattern after the model is initialized.
-
-        Args:
-            __context (Any): The context in which the model is initialized.
-        """
-        self._compiled = compile(self.pattern, self.flags)
-
-    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.
-
-        """
-        match = self._compiled.search(text)
+    flags: int = re.DOTALL | re.MULTILINE | re.IGNORECASE
+    """Flags to control regex behavior (DOTALL, MULTILINE, IGNORECASE by default)."""
+    capture_type: Optional[str] = None
+    """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 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 CONFIG.general.use_json_repair:
+                logger.debug("Applying JSON repair to text.")
+                if isinstance(text, str):
+                    return repair_json(text, ensure_ascii=False)
+                return [repair_json(item, ensure_ascii=False) for item in text]
+            case _:
+                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(match.group(g) for g in self.target_groups)
-            logger.debug(f"Captured text: {'\n\n'.join(cap)}")
+            cap = tuple(groups[g - 1] for g in self.target_groups)
+            logger.debug(f"Captured texts: {'\n==\n'.join(cap)}")
             return cap
-        cap = match.group(1)
+        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)
-        except (ValueError, SyntaxError) as e:
-            logger.error(f"Failed to convert text using {convertor.__name__} to convert.\nerror: {e}\n {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[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 obj: all(isinstance(e, elements_type) for e in obj))
+        if 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  # 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.
+        """Capture a code block of the given language."""
+        return cls(pattern=f"```{language}(.*?)```", capture_type=language)
 
-        Args:
-            language (str): The text containing the code block.
-
-        Returns:
-            Self: The instance of the class with the captured code block.
-        """
-        return cls(pattern=f"```{language}\n(.*?)\n```")
+    @classmethod
+    @lru_cache(32)
+    def capture_generic_block(cls, language: str) -> Self:
+        """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")
 PythonCapture = Capture.capture_code_block("python")
-MarkdownCapture = Capture.capture_code_block("markdown")
-CodeBlockCapture = Capture(pattern="```.*?\n(.*?)\n```")
+GenericCapture = Capture.capture_generic_block("String")