ssc_codegen 0.10.2__tar.gz → 0.12.0__tar.gz

{ssc_codegen-0.10.2 → ssc_codegen-0.12.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ssc_codegen
-Version: 0.10.2
+Version: 0.12.0
 Summary: Python-dsl code converter to html parser for web scraping 
 Project-URL: Documentation, https://github.com/vypivshiy/selector_schema_codegen#readme
 Project-URL: Issues, https://github.com/vypivshiy/selector_schema_codegen/issues
@@ -248,8 +248,10 @@ You can use any html source:
 ## See also
 
 
-- [Brief](docs/briefing.md) about css selectors and regular expressions.
-- [LLM]("llm.md") experimental prompt for generate code
+- [Brief](docs/briefing.md) about css selectors and regular expressions
+- [Explain](docs/explain.md) short document on how to understand DSL syntax
+- [LLM](llm.md) experimental prompt for generate code
+- [Explain](docs/explain.md) short note how to explain and read sscgen schema configs
 - [Quickstart](docs/quickstart.md) about css selectors and regular expressions.
 - [Tutorial](docs/tutorial.md) basic usage ssc-gen
 - [AST reference](docs/ast_reference.md) about generation code from AST

{ssc_codegen-0.10.2 → ssc_codegen-0.12.0}/README.md

@@ -211,8 +211,10 @@ You can use any html source:
 ## See also
 
 
-- [Brief](docs/briefing.md) about css selectors and regular expressions.
-- [LLM]("llm.md") experimental prompt for generate code
+- [Brief](docs/briefing.md) about css selectors and regular expressions
+- [Explain](docs/explain.md) short document on how to understand DSL syntax
+- [LLM](llm.md) experimental prompt for generate code
+- [Explain](docs/explain.md) short note how to explain and read sscgen schema configs
 - [Quickstart](docs/quickstart.md) about css selectors and regular expressions.
 - [Tutorial](docs/tutorial.md) basic usage ssc-gen
 - [AST reference](docs/ast_reference.md) about generation code from AST

{ssc_codegen-0.10.2 → ssc_codegen-0.12.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ssc_codegen"
-version = "0.10.2"
+version = "0.12.0"
 description = "Python-dsl code converter to html parser for web scraping "
 readme = "README.md"
 requires-python = ">=3.10"

{ssc_codegen-0.10.2 → ssc_codegen-0.12.0}/ssc_codegen/__init__.py

@@ -1,4 +1,4 @@
-from ssc_codegen.document import HTMLDocument, ClassVarDocument, StringDocument, ArrayDocument, AssertDocument, NestedDocument, \
+from ssc_codegen.document import DocumentElementsFilter, HTMLDocument, ClassVarDocument, StringDocument, ArrayDocument, AssertDocument, NestedDocument, \
     DefaultDocument, \
     NumericDocument, JsonDocument, BooleanDocument, DocumentFilter
 from ssc_codegen.json_struct import Json
@@ -7,7 +7,7 @@ from ssc_codegen.schema import ItemSchema, DictSchema, ListSchema, FlatListSchem
 
 setup_logger()
 
-VERSION = "0.10.2"
+VERSION = "0.12.0"
 
 
 class __MISSING(object):
@@ -68,7 +68,12 @@ def F() -> DocumentFilter:
     return DocumentFilter()
 
 
-def CV(value, self_cls_path: str | None = None, *, returns: bool = False) -> ClassVarDocument:
+def FE() -> DocumentElementsFilter:
+    """Shortcut as a DocumentElementsFilter() object"""
+    return DocumentElementsFilter()
+
+
+def CV(value: int | str | float | bool | None | list, self_cls_path: str | None = None, *, returns: bool = False) -> ClassVarDocument:
     """Shortcut as ClassVarDocument(value, self_cls, parse_returns) object
 
     pass `self_cls_path` argument if need use this var inner schema context:
@@ -90,5 +95,4 @@ class A(ItemShema):
 ```
 
     """
-    
     return ClassVarDocument(value, self_cls_path, parse_returns=returns)

{ssc_codegen-0.10.2 → ssc_codegen-0.12.0}/ssc_codegen/_compat.py

@@ -1,7 +1,10 @@
 import sys
 import warnings
 import functools
+from typing import Callable, ParamSpec, TypeVar
 
+P = ParamSpec("P")
+R = TypeVar("R")
 
 if sys.version_info >= (3, 11):
     from enum import StrEnum
@@ -12,10 +15,10 @@ else:
         pass
 
 
-def deprecated(reason=""):
-    def decorator(func):
+def deprecated(reason: str = "") -> Callable[[Callable[P, R]], Callable[P, R]]:
+    def decorator(func: Callable[P, R]) -> Callable[P, R]:
         @functools.wraps(func)
-        def wrapper(*args, **kwargs):
+        def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
             warnings.warn(
                 f"Function {func.__name__} is deprecated. {reason}",
                 category=DeprecationWarning,

ssc_codegen-0.12.0/ssc_codegen/ast_/__init__.py

@@ -0,0 +1,129 @@
+from .base import BaseAstNode
+from .nodes_array import (
+    ExprIndex,
+    ExprToListLength,
+    ExprListStringJoin,
+    ExprListUnique
+)
+from .nodes_cast import (
+    ExprNested,
+    ExprJsonify,
+    ExprToInt,
+    ExprToFloat,
+    ExprToListInt,
+    ExprToListFloat,
+    ExprToBool,
+    ExprJsonifyDynamic
+)
+from .nodes_core import (
+    ExprReturn,
+    ExprNoReturn,
+    ExprDefaultValueEnd,
+    ExprDefaultValueStart,
+    ExprDefaultValueWrapper,
+    ModuleProgram,
+    Docstring,
+    ModuleImports,
+    StructInitMethod,
+    StructPreValidateMethod,
+    StructFieldMethod,
+    StructPartDocMethod,
+    StartParseMethod,
+    StructParser,
+    JsonStruct,
+    JsonStructField,
+    TypeDef,
+    TypeDefField,
+    ExprCallStructMethod,
+    ExprClassVar,
+    ExprCallStructClassVar,
+    CodeStart,
+    CodeEnd
+)
+from .nodes_filter import (
+    FilterOr,
+    FilterAnd,
+    FilterNot,
+    FilterNotEqual,
+    FilterEqual,
+    FilterStrIn,
+    FilterStrStarts,
+    FilterStrEnds,
+    FilterStrRe,
+    ExprFilter,
+    FilterStrLenEq,
+    FilterStrLenNe,
+    FilterStrLenLt,
+    FilterStrLenLe,
+    FilterStrLenGt,
+    FilterStrLenGe,
+    ExprDocumentFilter,
+    FilterDocCss,
+    FilterDocHasAttr,
+    FilterDocHasRaw,
+    FilterDocHasText,
+    FilterDocIsRegexRaw,
+    FilterDocIsRegexText,
+    FilterDocXpath,
+    FilterDocAttrContains,
+    FilterDocAttrEnds,
+    FilterDocAttrEqual,
+    FilterDocAttrRegex,
+    FilterDocAttrStarts,
+)
+
+from .nodes_selectors import (
+    ExprCss,
+    ExprCssAll,
+    ExprXpathAll,
+    ExprXpath,
+    ExprGetHtmlText,
+    ExprGetHtmlRaw,
+    ExprGetHtmlAttr,
+    ExprGetHtmlAttrAll,
+    ExprGetHtmlRawAll,
+    ExprGetHtmlTextAll,
+    ExprMapAttrs,
+    ExprMapAttrsAll,
+    ExprCssElementRemove,
+    ExprXpathElementRemove
+)
+from .nodes_string import (
+    ExprStringTrim,
+    ExprStringRegex,
+    ExprStringSplit,
+    ExprStringReplace,
+    ExprStringLeftTrim,
+    ExprStringFormat,
+    ExprListStringTrim,
+    ExprStringRegexAll,
+    ExprStringRegexSub,
+    ExprStringRightTrim,
+    ExprListStringFormat,
+    ExprListStringReplace,
+    ExprListStringRightTrim,
+    ExprListStringLeftTrim,
+    ExprListStringRegexSub,
+    ExprStringRmPrefix,
+    ExprStringRmSuffix,
+    ExprStringRmPrefixAndSuffix,
+    ExprListStringRmPrefixAndSuffix,
+    ExprListStringRmPrefix,
+    ExprListStringRmSuffix,
+    ExprStringMapReplace,
+    ExprListStringMapReplace,
+    ExprStringUnescape,
+    ExprListStringUnescape
+)
+from .nodes_validate import (
+    ExprIsCss,
+    ExprIsEqual,
+    ExprStringIsRegex,
+    ExprIsXpath,
+    ExprIsNotEqual,
+    ExprIsContains,
+    ExprListStringAnyRegex,
+    ExprListStringAllRegex,
+    ExprHasAttr,
+    ExprListHasAttr
+)

{ssc_codegen-0.10.2 → ssc_codegen-0.12.0}/ssc_codegen/ast_/base.py

@@ -45,10 +45,16 @@ class BaseAstNode(Generic[T_MAPPING_FIELD, T_ARGUMENTS]):
         """extract all values from kwargs field wout keys"""
         return tuple(self.kwargs.values())  # type: ignore
 
-    # todo: cached property?
     @property
     def index(self) -> int:
         if self.parent:
+            # self.parent.body.index(self) add side effect if expr has same operations:
+            #      0      1      1       1
+            # D().raw().trim().trim().trim()
+            # use compare by id
+            for i, child in enumerate(self.parent.body):
+                if id(child) == id(self):
+                    return i
             return self.parent.body.index(self)
         return -1
 
@@ -92,10 +98,10 @@ class BaseAstNode(Generic[T_MAPPING_FIELD, T_ARGUMENTS]):
 
     def find_node_all(
         self, func: Callable[["BaseAstNode"], bool]
-    ) -> "BaseAstNode":
+    ) -> list["BaseAstNode"]:
         """find nodes in body by func filter"""
         if len(self.body) == 0:
-            return []
+            return []  # type: ignore
         return [i for i in self.body if i.kind == func(i)]
 
     def find_node_by_token(
@@ -106,7 +112,7 @@ class BaseAstNode(Generic[T_MAPPING_FIELD, T_ARGUMENTS]):
 
     def find_nodes_by_token(self, token_type: TokenType) -> list["BaseAstNode"]:
         """find nodes by TokenType"""
-        return self.find_nodes_by_token(lambda n: n.kind == token_type)
+        return self.find_nodes_by_token(lambda n: n.kind == token_type)  # type: ignore[arg-type]
 
 
 @dataclass(kw_only=True)

{ssc_codegen-0.10.2 → ssc_codegen-0.12.0}/ssc_codegen/ast_/nodes_core.py

@@ -107,7 +107,7 @@ class ExprCallStructMethod(
 
 
 KW_EXPR_CALL_CLASSVAR = TypedDict(
-    "KW_EXPR_CALL_LITERAL",
+    "KW_EXPR_CALL_CLASSVAR",
     {"struct_name": str, "field_name": str, "type": VariableType},
 )
 ARGS_EXPR_CALL_CLASSVAR = tuple[str, str, VariableType]
@@ -253,7 +253,7 @@ class ExprNoReturn(_DisableReprBody, BaseAstNode[T_EMPTY_KWARGS, tuple]):
 # regex pattern auto converts to string
 T_CLASSVAR = int | str | bool | float | None
 KW_CLASSVAR = TypedDict(
-    "KW_LITERAL",
+    "KW_CLASSVAR",
     {
         "value": T_CLASSVAR,
         "struct_name": str,
@@ -262,7 +262,7 @@ KW_CLASSVAR = TypedDict(
         "is_regex": bool,
     },
 )
-ARGS_CLASSVAR = tuple[T_CLASSVAR, str, str]
+ARGS_CLASSVAR = tuple[T_CLASSVAR, str, str, bool, bool]
 
 
 @dataclass(kw_only=True)
@@ -286,7 +286,7 @@ class ExprClassVar(_DisableReprBody, BaseAstNode[KW_CLASSVAR, ARGS_CLASSVAR]):
         return self.kwargs["value"]
 
     @value.setter
-    def value(self, val) -> None:
+    def value(self, val: T_CLASSVAR) -> None:
         self.kwargs["value"] = val
 
     @property

ssc_codegen-0.12.0/ssc_codegen/ast_/nodes_filter.py

@@ -0,0 +1,285 @@
+from dataclasses import dataclass
+from typing import TypedDict, ClassVar
+
+from ssc_codegen.ast_.base import BaseAstNode, T_EMPTY_KWARGS
+from ssc_codegen.tokens import TokenType, VariableType
+
+
+# TODO: static analyzer for filter operations
+# TODO: implement operators for DOCUMENT, INT, FLOAT
+
+
+@dataclass(kw_only=True)
+class FilterOr(BaseAstNode[T_EMPTY_KWARGS, tuple]):
+    kind: ClassVar[TokenType] = TokenType.FILTER_OR
+    # cast for reuse in Elements filters
+    # real accept: VariableType.STRING, VariableType.DOCUMENT
+    accept_type: VariableType = VariableType.ANY
+    ret_type: VariableType = VariableType.ANY
+    # TODO: typing body accept Filter-like nodes
+
+
+@dataclass(kw_only=True)
+class FilterAnd(BaseAstNode[T_EMPTY_KWARGS, tuple]):
+    kind: ClassVar[TokenType] = TokenType.FILTER_AND
+    accept_type: VariableType = VariableType.ANY
+    ret_type: VariableType = VariableType.ANY
+    # TODO: typing body accept Filter-like nodes
+
+
+@dataclass(kw_only=True)
+class FilterNot(BaseAstNode[T_EMPTY_KWARGS, tuple]):
+    kind: ClassVar[TokenType] = TokenType.FILTER_NOT
+    accept_type: VariableType = VariableType.ANY
+    ret_type: VariableType = VariableType.ANY
+    # TODO: typing body accept Filter-like nodes
+
+
+KW_STR_IN = TypedDict("KW_STR_IN", {"substr": tuple[str, ...]})
+ARGS_STR_IN = tuple[tuple[str, ...]]
+
+KW_STR_STARTS_OR_ENDS = TypedDict(
+    "KW_STR_STARTS_OR_ENDS", {"substr": tuple[str, ...]}
+)
+ARGS_STR_STARTS_OR_ENDS = tuple[tuple[str, ...]]
+
+
+@dataclass(kw_only=True)
+class FilterStrIn(BaseAstNode[KW_STR_IN, ARGS_STR_IN]):
+    kind: ClassVar[TokenType] = TokenType.FILTER_STR_IN
+    accept_type: VariableType = VariableType.STRING
+    ret_type: VariableType = VariableType.STRING
+
+
+@dataclass(kw_only=True)
+class FilterStrStarts(
+    BaseAstNode[KW_STR_STARTS_OR_ENDS, ARGS_STR_STARTS_OR_ENDS]
+):
+    kind: ClassVar[TokenType] = TokenType.FILTER_STR_STARTS
+    accept_type: VariableType = VariableType.STRING
+    ret_type: VariableType = VariableType.STRING
+
+
+@dataclass(kw_only=True)
+class FilterStrEnds(
+    BaseAstNode[KW_STR_STARTS_OR_ENDS, ARGS_STR_STARTS_OR_ENDS]
+):
+    kind: ClassVar[TokenType] = TokenType.FILTER_STR_ENDS
+    accept_type: VariableType = VariableType.STRING
+    ret_type: VariableType = VariableType.STRING
+
+
+KW_STR_RE = TypedDict("KW_STR_RE", {"pattern": str, "ignore_case": bool})
+ARGS_STR_RE = tuple[str, bool]
+
+
+@dataclass(kw_only=True)
+class FilterStrRe(BaseAstNode[KW_STR_RE, ARGS_STR_RE]):
+    kind: ClassVar[TokenType] = TokenType.FILTER_STR_RE
+    accept_type: VariableType = VariableType.STRING
+    ret_type: VariableType = VariableType.STRING
+
+
+KW_STR_LEN = TypedDict("KW_STR_LEN", {"length": int})
+ARGS_STR_LEN = tuple[int]
+
+
+@dataclass(kw_only=True)
+class FilterStrLenEq(BaseAstNode[KW_STR_LEN, ARGS_STR_LEN]):
+    kind: ClassVar[TokenType] = TokenType.FILTER_STR_LEN_EQ
+    accept_type: VariableType = VariableType.STRING
+    ret_type: VariableType = VariableType.STRING
+
+
+@dataclass(kw_only=True)
+class FilterStrLenNe(BaseAstNode[KW_STR_LEN, ARGS_STR_LEN]):
+    kind: ClassVar[TokenType] = TokenType.FILTER_STR_LEN_NE
+    accept_type: VariableType = VariableType.STRING
+    ret_type: VariableType = VariableType.STRING
+
+
+@dataclass(kw_only=True)
+class FilterStrLenLt(BaseAstNode[KW_STR_LEN, ARGS_STR_LEN]):
+    kind: ClassVar[TokenType] = TokenType.FILTER_STR_LEN_LT
+    accept_type: VariableType = VariableType.STRING
+    ret_type: VariableType = VariableType.STRING
+
+
+@dataclass(kw_only=True)
+class FilterStrLenLe(BaseAstNode[KW_STR_LEN, ARGS_STR_LEN]):
+    kind: ClassVar[TokenType] = TokenType.FILTER_STR_LEN_LE
+    accept_type: VariableType = VariableType.STRING
+    ret_type: VariableType = VariableType.STRING
+
+
+@dataclass(kw_only=True)
+class FilterStrLenGt(BaseAstNode[KW_STR_LEN, ARGS_STR_LEN]):
+    kind: ClassVar[TokenType] = TokenType.FILTER_STR_LEN_GT
+    accept_type: VariableType = VariableType.STRING
+    ret_type: VariableType = VariableType.STRING
+
+
+@dataclass(kw_only=True)
+class FilterStrLenGe(BaseAstNode[KW_STR_LEN, ARGS_STR_LEN]):
+    kind: ClassVar[TokenType] = TokenType.FILTER_STR_LEN_GE
+    accept_type: VariableType = VariableType.STRING
+    ret_type: VariableType = VariableType.STRING
+
+
+# TODO: provide API for int, float, etc
+KW_STR_EQ_OR_NE = TypedDict("KW_STR_EQ_OR_NE", {"values": tuple[str, ...]})
+ARGS_STR_EQ_OR_NE = tuple[tuple[str, ...]]
+
+
+@dataclass(kw_only=True)
+class FilterEqual(BaseAstNode[KW_STR_EQ_OR_NE, ARGS_STR_EQ_OR_NE]):
+    kind: ClassVar[TokenType] = TokenType.FILTER_EQ
+    accept_type: VariableType = VariableType.STRING
+    ret_type: VariableType = VariableType.STRING
+
+
+@dataclass(kw_only=True)
+class FilterNotEqual(BaseAstNode[KW_STR_EQ_OR_NE, ARGS_STR_EQ_OR_NE]):
+    kind: ClassVar[TokenType] = TokenType.FILTER_NE
+    accept_type: VariableType = VariableType.STRING
+    ret_type: VariableType = VariableType.STRING
+
+
+@dataclass(kw_only=True)
+class ExprFilter(BaseAstNode[T_EMPTY_KWARGS, tuple]):
+    kind: ClassVar[TokenType] = TokenType.EXPR_FILTER
+    accept_type: VariableType = VariableType.LIST_STRING
+    ret_type: VariableType = VariableType.LIST_STRING
+    # TODO: typing body accept Filter-like nodes
+
+
+# Elements filters
+@dataclass(kw_only=True)
+class ExprDocumentFilter(BaseAstNode[T_EMPTY_KWARGS, tuple]):
+    kind: ClassVar[TokenType] = TokenType.EXPR_DOC_FILTER
+    accept_type: VariableType = VariableType.LIST_DOCUMENT
+    ret_type: VariableType = VariableType.LIST_DOCUMENT
+
+
+KW_FILTER_CSS_OR_XPATH = TypedDict("KW_FILTER_CSS", {"query": str})
+ARGS_FILTER_CSS_OR_XPATH = tuple[str]
+
+
+@dataclass(kw_only=True)
+class FilterDocCss(
+    BaseAstNode[KW_FILTER_CSS_OR_XPATH, ARGS_FILTER_CSS_OR_XPATH]
+):
+    kind: ClassVar[TokenType] = TokenType.FILTER_DOC_CSS
+    accept_type: VariableType = VariableType.DOCUMENT
+    ret_type: VariableType = VariableType.DOCUMENT
+
+
+@dataclass(kw_only=True)
+class FilterDocXpath(
+    BaseAstNode[KW_FILTER_CSS_OR_XPATH, ARGS_FILTER_CSS_OR_XPATH]
+):
+    kind: ClassVar[TokenType] = TokenType.FILTER_DOC_XPATH
+    accept_type: VariableType = VariableType.DOCUMENT
+    ret_type: VariableType = VariableType.DOCUMENT
+
+
+KW_FILTER_HAS_TEXT = TypedDict(
+    "KW_FILTER_HAS_TEXT", {"values": tuple[str, ...]}
+)
+ARGS_FILTER_HAS_TEXT = tuple[tuple[str, ...]]
+
+
+@dataclass(kw_only=True)
+class FilterDocHasText(BaseAstNode[KW_FILTER_HAS_TEXT, ARGS_FILTER_HAS_TEXT]):
+    kind: ClassVar[TokenType] = TokenType.FILTER_DOC_HAS_TEXT
+    accept_type: VariableType = VariableType.DOCUMENT
+    ret_type: VariableType = VariableType.DOCUMENT
+
+
+@dataclass(kw_only=True)
+class FilterDocHasRaw(BaseAstNode[KW_FILTER_HAS_TEXT, ARGS_FILTER_HAS_TEXT]):
+    kind: ClassVar[TokenType] = TokenType.FILTER_DOC_HAS_RAW
+    accept_type: VariableType = VariableType.DOCUMENT
+    ret_type: VariableType = VariableType.DOCUMENT
+
+
+KW_FILTER_HAS_ATTR = TypedDict("KW_FILTER_HAS_ATTR", {"keys": tuple[str, ...]})
+ARGS_FILTER_HAS_ATTR = tuple[tuple[str, ...]]
+
+
+@dataclass(kw_only=True)
+class FilterDocHasAttr(BaseAstNode[KW_FILTER_HAS_ATTR, ARGS_FILTER_HAS_ATTR]):
+    kind: ClassVar[TokenType] = TokenType.FILTER_DOC_HAS_ATTR
+    accept_type: VariableType = VariableType.DOCUMENT
+    ret_type: VariableType = VariableType.DOCUMENT
+
+
+KW_FILTER_ATTR = TypedDict(
+    "KW_FILTER_ATTR", {"key": str, "values": tuple[str, ...]}
+)
+ARGS_FILTER_ATTR = tuple[str, tuple[str, ...]]
+
+
+@dataclass(kw_only=True)
+class FilterDocAttrEqual(BaseAstNode[KW_FILTER_ATTR, ARGS_FILTER_ATTR]):
+    kind: ClassVar[TokenType] = TokenType.FILTER_DOC_ATTR_EQ
+    accept_type: VariableType = VariableType.DOCUMENT
+    ret_type: VariableType = VariableType.DOCUMENT
+
+
+@dataclass(kw_only=True)
+class FilterDocAttrStarts(BaseAstNode[KW_FILTER_ATTR, ARGS_FILTER_ATTR]):
+    kind: ClassVar[TokenType] = TokenType.FILTER_DOC_ATTR_STARTS
+    accept_type: VariableType = VariableType.DOCUMENT
+    ret_type: VariableType = VariableType.DOCUMENT
+
+
+@dataclass(kw_only=True)
+class FilterDocAttrEnds(BaseAstNode[KW_FILTER_ATTR, ARGS_FILTER_ATTR]):
+    kind: ClassVar[TokenType] = TokenType.FILTER_DOC_ATTR_ENDS
+    accept_type: VariableType = VariableType.DOCUMENT
+    ret_type: VariableType = VariableType.DOCUMENT
+
+
+@dataclass(kw_only=True)
+class FilterDocAttrContains(BaseAstNode[KW_FILTER_ATTR, ARGS_FILTER_ATTR]):
+    kind: ClassVar[TokenType] = TokenType.FILTER_DOC_ATTR_CONTAINS
+    accept_type: VariableType = VariableType.DOCUMENT
+    ret_type: VariableType = VariableType.DOCUMENT
+
+
+KW_FILTER_ATTR_RE = TypedDict(
+    "KW_FILTER_ATTR", {"key": str, "pattern": str, "ignore_case": bool}
+)
+ARGS_FILTER_ATTR_RE = tuple[str, str, bool]
+
+
+@dataclass(kw_only=True)
+class FilterDocAttrRegex(BaseAstNode[KW_FILTER_ATTR_RE, ARGS_FILTER_ATTR_RE]):
+    kind: ClassVar[TokenType] = TokenType.FILTER_DOC_ATTR_RE_MATCH
+    accept_type: VariableType = VariableType.DOCUMENT
+    ret_type: VariableType = VariableType.DOCUMENT
+
+
+KW_FILTER_IS_REGEX = TypedDict(
+    "KW_FILTER_IS_REGEX", {"pattern": str, "ignore_case": bool}
+)
+ARGS_FILTER_IS_REGEX = tuple[str, bool]
+
+
+@dataclass(kw_only=True)
+class FilterDocIsRegexText(
+    BaseAstNode[KW_FILTER_IS_REGEX, ARGS_FILTER_IS_REGEX]
+):
+    kind: ClassVar[TokenType] = TokenType.FILTER_DOC_IS_RE_TEXT
+    accept_type: VariableType = VariableType.DOCUMENT
+    ret_type: VariableType = VariableType.DOCUMENT
+
+
+@dataclass(kw_only=True)
+class FilterDocIsRegexRaw(
+    BaseAstNode[KW_FILTER_IS_REGEX, ARGS_FILTER_IS_REGEX]
+):
+    kind: ClassVar[TokenType] = TokenType.FILTER_DOC_IS_RE_RAW
+    accept_type: VariableType = VariableType.DOCUMENT
+    ret_type: VariableType = VariableType.DOCUMENT