ssc_codegen 0.8.4__tar.gz → 0.8.6__tar.gz

{ssc_codegen-0.8.4 → ssc_codegen-0.8.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ssc_codegen
-Version: 0.8.4
+Version: 0.8.6
 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
@@ -26,6 +26,7 @@ Requires-Dist: ichrome>=4.0.4
 Requires-Dist: jinja2>=3.1.6
 Requires-Dist: lxml>=5.3.0
 Requires-Dist: parsel>=1.10.0
+Requires-Dist: soupsieve>=2.6
 Requires-Dist: typer>=0.15.1
 Requires-Dist: typing-extensions; python_version < '3.11'
 Description-Content-Type: text/markdown

{ssc_codegen-0.8.4 → ssc_codegen-0.8.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ssc_codegen"
-version = "0.8.4"
+version = "0.8.6"
 description = "Python-dsl code converter to html parser for web scraping "
 readme = "README.md"
 requires-python = ">=3.10"
@@ -12,6 +12,7 @@ dependencies = [
     "jinja2>=3.1.6",
     "lxml>=5.3.0",
     "parsel>=1.10.0",
+    "soupsieve>=2.6",
     "typer>=0.15.1",
     "typing_extensions;python_version<'3.11'",
 ]
@@ -106,4 +107,4 @@ omit = [
     "*/.venv/*",
     "*/scripts/*",
     "*/tests/*"
-]
+]

{ssc_codegen-0.8.4 → ssc_codegen-0.8.6}/ssc_codegen/__init__.py

@@ -7,7 +7,7 @@ from ssc_codegen.schema import ItemSchema, DictSchema, ListSchema, FlatListSchem
 
 setup_logger()
 
-VERSION = "0.8.4"
+VERSION = "0.8.6"
 
 
 class __MISSING(object):

{ssc_codegen-0.8.4 → ssc_codegen-0.8.6}/ssc_codegen/ast_/__init__.py

@@ -29,4 +29,5 @@ from .nodes_string import ExprStringTrim, ExprStringRegex, ExprStringSplit, Expr
     ExprListStringRegexSub, \
     ExprStringRmPrefix, ExprStringRmSuffix, ExprStringRmPrefixAndSuffix, ExprListStringRmPrefixAndSuffix, \
     ExprListStringRmPrefix, ExprListStringRmSuffix
-from .nodes_validate import ExprIsCss, ExprIsEqual, ExprIsRegex, ExprIsXpath, ExprIsNotEqual, ExprIsContains
+from .nodes_validate import ExprIsCss, ExprIsEqual, ExprStringIsRegex, ExprIsXpath, ExprIsNotEqual, ExprIsContains, \
+    ExprListStringAnyRegex, ExprListStringAllRegex

{ssc_codegen-0.8.4 → ssc_codegen-0.8.6}/ssc_codegen/ast_/nodes_validate.py

@@ -59,12 +59,26 @@ ARGS_IS_REGEX = tuple[str, bool, str]
 
 
 @dataclass(kw_only=True)
-class ExprIsRegex(BaseAstNode[KW_IS_REGEX, ARGS_IS_REGEX]):
-    kind: ClassVar[TokenType] = TokenType.IS_REGEX_MATCH
+class ExprStringIsRegex(BaseAstNode[KW_IS_REGEX, ARGS_IS_REGEX]):
+    kind: ClassVar[TokenType] = TokenType.IS_STRING_REGEX_MATCH
     accept_type: VariableType = VariableType.STRING
     ret_type: VariableType = VariableType.STRING
 
 
+@dataclass(kw_only=True)
+class ExprListStringAnyRegex(BaseAstNode[KW_IS_REGEX, ARGS_IS_REGEX]):
+    kind: ClassVar[TokenType] = TokenType.ANY_LIST_STRING_REGEX_MATCH
+    accept_type: VariableType = VariableType.LIST_STRING
+    ret_type: VariableType = VariableType.LIST_STRING
+
+
+@dataclass(kw_only=True)
+class ExprListStringAllRegex(BaseAstNode[KW_IS_REGEX, ARGS_IS_REGEX]):
+    kind: ClassVar[TokenType] = TokenType.ALL_LIST_STRING_REGEX_MATCH
+    accept_type: VariableType = VariableType.LIST_STRING
+    ret_type: VariableType = VariableType.LIST_STRING
+
+
 KW_IS_SELECT = TypedDict("KW_IS_SELECT", {"query": str, "msg": str})
 ARGS_IS_SELECT = tuple[str, str]
 

{ssc_codegen-0.8.4 → ssc_codegen-0.8.6}/ssc_codegen/ast_build/utils.py

@@ -95,9 +95,13 @@ def exec_module_code(path: str | Path, add_sys_path: bool = True) -> ModuleType:
     module = ModuleType("_")
     abs_path = path.resolve()
     # required for correct imports (eg: constants)
+    # TODO: calculate configs dirs depth
     if add_sys_path and str(abs_path.parent) not in sys.path:
         sys.path.append(str(abs_path.parent))
 
+    if add_sys_path and str(abs_path.parent.parent) not in sys.path:
+        sys.path.append(str(abs_path.parent.parent))
+
     code = Path(abs_path).read_text()
     exec(code, module.__dict__)
     return module

{ssc_codegen-0.8.4 → ssc_codegen-0.8.6}/ssc_codegen/cli/main.py

@@ -100,6 +100,13 @@ def generate_code(
         LOGGER.info("TOGGLE debug generated tokens")
         converter.debug_instructions = True
     for file_cfg in ssc_files:
+        # check ssc-gen files
+        if (
+            file_cfg.suffix != ".py"
+            and "ssc_codegen" not in file_cfg.read_text()
+        ):
+            LOGGER.info("Skip %s (not ssc-gen config)", file_cfg.name)
+            continue
         name = file_cfg.name.split(".")[0]
         out_file = f"{prefix}{name}{suffix}"
         LOGGER.info("Make AST %s...", file_cfg.name)

{ssc_codegen-0.8.4 → ssc_codegen-0.8.6}/ssc_codegen/converters/go_goquery.py

@@ -90,7 +90,7 @@ from ssc_codegen.ast_ import (
     ExprIsEqual,
     ExprIsNotEqual,
     ExprIsContains,
-    ExprIsRegex,
+    ExprStringIsRegex,
     ExprIsCss,
     ExprToInt,
     ExprToListInt,
@@ -122,6 +122,8 @@ from ssc_codegen.ast_ import (
     ExprListStringRmSuffix,
     ExprStringRmPrefixAndSuffix,
     ExprListStringRmPrefixAndSuffix,
+    ExprListStringAnyRegex,
+    ExprListStringAllRegex,
 )
 from ssc_codegen.converters.base import BaseCodeConverter
 from ssc_codegen.converters.helpers import (
@@ -166,6 +168,8 @@ from ssc_codegen.converters.templates.go_goquery import (
     J2_PRE_LIST_STR_RM_SUFFIX,
     J2_PRE_STR_RM_PREFIX_AND_SUFFIX,
     J2_PRE_LIST_STR_RM_PREFIX_AND_SUFFIX,
+    J2_PRE_LIST_STR_ANY_IS_RE,
+    J2_PRE_LIST_STR_ALL_IS_RE,
 )
 from ssc_codegen.str_utils import (
     wrap_backtick,
@@ -853,8 +857,8 @@ def pre_is_contains(node: ExprIsContains) -> str:
     return J2_PRE_IS_CONTAINS.render(**context)
 
 
-@CONVERTER(ExprIsRegex.kind)
-def pre_is_regex(node: ExprIsRegex) -> str:
+@CONVERTER(ExprStringIsRegex.kind)
+def pre_is_regex(node: ExprStringIsRegex) -> str:
     prv, nxt = prev_next_var(node)
     pattern, ignore_case, msg = node.unpack_args()
 
@@ -880,6 +884,48 @@ def pre_is_regex(node: ExprIsRegex) -> str:
     return J2_PRE_IS_REGEX.render(**context)
 
 
+@CONVERTER(ExprListStringAnyRegex.kind)
+def pre_list_str_any_is_regex(node: ExprListStringAnyRegex) -> str:
+    prv, nxt = prev_next_var(node)
+    pattern, ignore_case, msg = node.unpack_args()
+    if ignore_case:
+        pattern = f"(?i){pattern}"
+    pattern = wrap_backtick(pattern)
+    msg = wrap_double_quotes(msg)
+    context = {
+        "prv": prv,
+        "nxt": nxt,
+        "pattern": pattern,  # Already processed with ignore_case and backticks
+        "msg": msg,
+        "have_default_expr": have_default_expr(node),
+        "is_pre_validate_parent": is_pre_validate_parent(node),
+        "is_last_var_no_ret": is_last_var_no_ret(node),
+        "return_type": RETURN_ERR_TYPES.get(get_last_ret_type(node), "nil"),
+    }
+    return J2_PRE_LIST_STR_ANY_IS_RE.render(**context)
+
+
+@CONVERTER(ExprListStringAllRegex.kind)
+def pre_list_str_all_is_regex(node: ExprListStringAllRegex) -> str:
+    prv, nxt = prev_next_var(node)
+    pattern, ignore_case, msg = node.unpack_args()
+    if ignore_case:
+        pattern = f"(?i){pattern}"
+    pattern = wrap_backtick(pattern)
+    msg = wrap_double_quotes(msg)
+    context = {
+        "prv": prv,
+        "nxt": nxt,
+        "pattern": pattern,  # Already processed with ignore_case and backticks
+        "msg": msg,
+        "have_default_expr": have_default_expr(node),
+        "is_pre_validate_parent": is_pre_validate_parent(node),
+        "is_last_var_no_ret": is_last_var_no_ret(node),
+        "return_type": RETURN_ERR_TYPES.get(get_last_ret_type(node), "nil"),
+    }
+    return J2_PRE_LIST_STR_ALL_IS_RE.render(**context)
+
+
 @CONVERTER(ExprIsCss.kind)
 def pre_is_css(node: ExprIsCss) -> str:
     prv, nxt = prev_next_var(node)

{ssc_codegen-0.8.4 → ssc_codegen-0.8.6}/ssc_codegen/converters/js_pure.py

@@ -54,7 +54,7 @@ from ssc_codegen.ast_ import (
     ExprIsEqual,
     ExprIsNotEqual,
     ExprIsContains,
-    ExprIsRegex,
+    ExprStringIsRegex,
     ExprToInt,
     ExprToListInt,
     ExprToFloat,
@@ -81,6 +81,8 @@ from ssc_codegen.ast_ import (
     ExprListStringRmSuffix,
     ExprStringRmPrefixAndSuffix,
     ExprListStringRmPrefixAndSuffix,
+    ExprListStringAnyRegex,
+    ExprListStringAllRegex,
 )
 from ssc_codegen.converters.base import BaseCodeConverter
 from ssc_codegen.converters.helpers import (
@@ -146,6 +148,11 @@ def pre_part_doc(_node: StructPartDocMethod) -> str:
     return "_splitDoc(v) " + BRACKET_START
 
 
+@CONVERTER.post(StructPartDocMethod.kind)
+def post_part_doc(_node: StructPartDocMethod) -> str:
+    return BRACKET_END
+
+
 @CONVERTER(StructParser.kind)
 def pre_struct_parser(node: StructParser) -> str:
     name = node.kwargs["name"]
@@ -437,11 +444,14 @@ def pre_is_contains(node: ExprIsContains) -> str:
     return expr + f"let {nxt} = {prv};"
 
 
-@CONVERTER(ExprIsRegex.kind)
-def pre_is_regex(node: ExprIsRegex) -> str:
+@CONVERTER(ExprStringIsRegex.kind)
+def pre_is_regex(node: ExprStringIsRegex) -> str:
     prv, nxt = prev_next_var(node)
     pattern, ignore_case, msg = node.unpack_args()
     pattern = f"/{node.pattern}/g"
+    if ignore_case:
+        pattern += "i"
+
     expr = f"if ({prv}.match({pattern}) === null) throw new Error({msg!r});"
     if is_last_var_no_ret(node):
         return expr
@@ -449,6 +459,38 @@ def pre_is_regex(node: ExprIsRegex) -> str:
     return expr + f"let {nxt} = {prv};"
 
 
+@CONVERTER(ExprListStringAnyRegex.kind)
+def pre_list_str_any_is_regex(node: ExprListStringAnyRegex) -> str:
+    # a.some(i => (new RegExp("foo")).test(i))
+    prv, nxt = prev_next_var(node)
+    pattern, ignore_case, msg = node.unpack_args()
+    pattern = f"/{node.pattern}/g"
+    if ignore_case:
+        pattern += "i"
+
+    expr = f"if (!{prv}.some(i => (new RegExp({pattern})).test(i))) throw new Error({msg!r});"
+    if is_last_var_no_ret(node):
+        return expr
+    # HACK: avoid recalc variables
+    return expr + f"let {nxt} = {prv};"
+
+
+@CONVERTER(ExprListStringAllRegex.kind)
+def pre_list_str_all_is_regex(node: ExprListStringAllRegex) -> str:
+    prv, nxt = prev_next_var(node)
+    # a.every(i => (new RegExp("foo")).test)
+    pattern, ignore_case, msg = node.unpack_args()
+    pattern = f"/{node.pattern}/g"
+    if ignore_case:
+        pattern += "i"
+
+    expr = f"if (!{prv}.every(i => (new RegExp({pattern})).test(i))) throw new Error({msg!r});"
+    if is_last_var_no_ret(node):
+        return expr
+    # HACK: avoid recalc variables
+    return expr + f"let {nxt} = {prv};"
+
+
 @CONVERTER(ExprIsCss.kind)
 def pre_is_css(node: ExprIsCss) -> str:
     prv, nxt = prev_next_var(node)

{ssc_codegen-0.8.4 → ssc_codegen-0.8.6}/ssc_codegen/converters/py_base.py

@@ -72,7 +72,7 @@ from ssc_codegen.ast_ import (
     ExprIsEqual,
     ExprIsNotEqual,
     ExprIsContains,
-    ExprIsRegex,
+    ExprStringIsRegex,
     ExprToInt,
     ExprToListInt,
     ExprToFloat,
@@ -85,6 +85,8 @@ from ssc_codegen.ast_ import (
     ExprListStringRmSuffix,
     ExprStringRmPrefixAndSuffix,
     ExprListStringRmPrefixAndSuffix,
+    ExprListStringAnyRegex,
+    ExprListStringAllRegex,
 )
 from ssc_codegen.converters.base import (
     BaseCodeConverter,
@@ -222,7 +224,9 @@ class BasePyCodeConverter(BaseCodeConverter):
             ExprIsEqual.kind: pre_is_equal,
             ExprIsNotEqual.kind: pre_is_not_equal,
             ExprIsContains.kind: pre_is_contains,
-            ExprIsRegex.kind: pre_is_regex,
+            ExprStringIsRegex.kind: pre_is_regex,
+            ExprListStringAllRegex.kind: pre_list_str_all_is_regex,
+            ExprListStringAnyRegex.kind: pre_list_str_any_is_regex,
             ExprToInt.kind: pre_to_int,
             ExprToListInt.kind: pre_to_list_int,
             ExprToFloat.kind: pre_to_float,
@@ -770,7 +774,7 @@ def pre_is_contains(node: ExprIsContains) -> str:
     return expr + "\n" + indent + f"{nxt} = {prv}"
 
 
-def pre_is_regex(node: ExprIsRegex) -> str:
+def pre_is_regex(node: ExprStringIsRegex) -> str:
     indent = (
         INDENT_DEFAULT_BODY if have_default_expr(node) else INDENT_METHOD_BODY
     )
@@ -783,6 +787,38 @@ def pre_is_regex(node: ExprIsRegex) -> str:
     return expr + "\n" + indent + f"{nxt} = {prv}"
 
 
+def pre_list_str_any_is_regex(node: ExprListStringAnyRegex) -> str:
+    indent = (
+        INDENT_DEFAULT_BODY if have_default_expr(node) else INDENT_METHOD_BODY
+    )
+    prv, nxt = prev_next_var(node)
+    pattern, ignore_case, msg = node.unpack_args()
+    expr = (
+        indent
+        + f"assert any(re.search({pattern!r}, i) for i in {prv}), {msg!r}"
+    )
+    if is_last_var_no_ret(node):
+        return expr
+    # HACK: avoid recalc variables
+    return expr + "\n" + indent + f"{nxt} = {prv}"
+
+
+def pre_list_str_all_is_regex(node: ExprListStringAllRegex) -> str:
+    indent = (
+        INDENT_DEFAULT_BODY if have_default_expr(node) else INDENT_METHOD_BODY
+    )
+    prv, nxt = prev_next_var(node)
+    pattern, ignore_case, msg = node.unpack_args()
+    expr = (
+        indent
+        + f"assert all(re.search({pattern!r}, i) for i in {prv}), {msg!r}"
+    )
+    if is_last_var_no_ret(node):
+        return expr
+    # HACK: avoid recalc variables
+    return expr + "\n" + indent + f"{nxt} = {prv}"
+
+
 def pre_to_int(node: ExprToInt) -> str:
     indent = (
         INDENT_DEFAULT_BODY if have_default_expr(node) else INDENT_METHOD_BODY

{ssc_codegen-0.8.4 → ssc_codegen-0.8.6}/ssc_codegen/converters/templates/go_goquery.py

@@ -409,3 +409,42 @@ for _, {{ tmp_var }} := range {{ prv }} {
     {{nxt}} = append({{ nxt }}, {{ tmp_var }});
 }
 """)
+
+
+J2_PRE_LIST_STR_ANY_IS_RE = Template("""
+re{{ nxt }} :=  regexp.MustCompile({{ pattern }});
+for _, {{ tmp_var }} := range {{ prv }} {
+    if re{{ nxt }}.MatchString({{ tmp_var }}) {
+        break;
+    }
+    {% if have_default_expr %}
+    panic(fmt.Errorf({{ msg }}));
+    {% elif is_pre_validate_parent %}
+    return nil, fmt.Errorf({{ msg }});
+    {% else %}
+    return {{ return_type }}, fmt.Errorf({{ msg }});
+    {% endif %}
+}
+{% if not is_last_var_no_ret %}
+{{ nxt }} := {{ prv }};
+{% endif %}
+""")
+
+
+J2_PRE_LIST_STR_ALL_IS_RE = Template("""
+re{{ nxt }} :=  regexp.MustCompile({{ pattern }});
+for _, {{ tmp_var }} := range {{ prv }} {
+    if !re{{ nxt }}.MatchString({{ tmp_var }}) {
+        {% if have_default_expr %}
+        panic(fmt.Errorf({{ msg }}));
+        {% elif is_pre_validate_parent %}
+        return nil, fmt.Errorf({{ msg }});
+        {% else %}
+        return {{ return_type }}, fmt.Errorf({{ msg }});
+        {% endif %}
+    }
+}
+{% if not is_last_var_no_ret %}
+{{ nxt }} := {{ prv }};
+{% endif %}
+""")

{ssc_codegen-0.8.4 → ssc_codegen-0.8.6}/ssc_codegen/document.py

@@ -41,7 +41,7 @@ from ssc_codegen.ast_ import (
     ExprIsEqual,
     ExprIsNotEqual,
     ExprIsContains,
-    ExprIsRegex,
+    ExprStringIsRegex,
     ExprNested,
     ExprToInt,
     ExprToListInt,
@@ -55,6 +55,8 @@ from ssc_codegen.ast_ import (
     ExprListStringRmSuffix,
     ExprStringRmPrefixAndSuffix,
     ExprListStringRmPrefixAndSuffix,
+    ExprListStringAllRegex,
+    ExprListStringAnyRegex,
 )
 from ssc_codegen.document_utlis import (
     analyze_re_expression,
@@ -953,6 +955,78 @@ class AssertDocument(BaseDocument):
         )
         return self
 
+    def any_is_re(
+        self, pattern: str | Pattern, msg: str = "", ignore_case: bool = False
+    ) -> Self:
+        """assert any value matched in array of strings by regex.
+        If in generated code check failed - throw exception with passed msg
+
+        EXPR DO NOT MODIFY variable
+
+        - accept LIST_STRING, return LIST_STRING
+        """
+        if not isinstance(pattern, str):
+            ignore_case = is_ignore_case_regex(pattern)
+        pattern = unverbosify_regex(pattern)
+        analyze_re_expression(pattern, allow_empty_groups=True)
+        if self.stack_last_ret != VariableType.LIST_STRING:
+            LOGGER.warning(
+                "any_is_re(%s): Expected type(s) %s got %s",
+                repr(pattern),
+                VariableType.LIST_STRING.name,
+                self.stack_last_ret.name,
+            )
+
+        self._add(
+            ExprListStringAnyRegex(
+                kwargs={
+                    "pattern": pattern,
+                    "ignore_case": ignore_case,
+                    "msg": msg,
+                }
+            )
+        )
+        return self
+
+    def all_is_re(
+        self, pattern: str | Pattern, msg: str = "", ignore_case: bool = False
+    ) -> Self:
+        """assert all value matched in array of strings by regex.
+        If in generated code check failed - throw exception with passed msg
+
+        EXPR DO NOT MODIFY variable
+
+        - accept LIST_STRING, return LIST_STRING
+        """
+        if not isinstance(pattern, str):
+            ignore_case = is_ignore_case_regex(pattern)
+        pattern = unverbosify_regex(pattern)
+        analyze_re_expression(pattern, allow_empty_groups=True)
+        if self.stack_last_ret != VariableType.LIST_STRING:
+            LOGGER.warning(
+                "all_is_re(%s): Expected type(s) %s got %s",
+                repr(pattern),
+                VariableType.LIST_STRING.name,
+                self.stack_last_ret.name,
+            )
+
+        self._add(
+            ExprListStringAllRegex(
+                kwargs={
+                    "pattern": pattern,
+                    "ignore_case": ignore_case,
+                    "msg": msg,
+                }
+            )
+        )
+        return self
+
+    def is_re(
+        self, pattern: str | Pattern, msg: str = "", ignore_case: bool = False
+    ) -> Self:
+        """shortcut of is_regex() method"""
+        return self.is_regex(pattern, msg, ignore_case)
+
     def is_regex(
         self, pattern: str | Pattern, msg: str = "", ignore_case: bool = False
     ) -> Self:
@@ -976,7 +1050,7 @@ class AssertDocument(BaseDocument):
             )
 
         self._add(
-            ExprIsRegex(
+            ExprStringIsRegex(
                 kwargs={
                     "pattern": pattern,
                     "ignore_case": ignore_case,

{ssc_codegen-0.8.4 → ssc_codegen-0.8.6}/ssc_codegen/selector_utils.py

@@ -5,6 +5,12 @@ from cssselect import HTMLTranslator, SelectorSyntaxError
 from lxml import etree
 from lxml.etree import XPathSyntaxError
 
+# cssselect not support CSS4 standard syntax
+# used for particularly provide CSS 4 API
+# https://facelessuser.github.io/soupsieve/selectors/
+from soupsieve import compile as css_compile
+from soupsieve.util import SelectorSyntaxError as SoupSieveSelectorSyntaxError
+
 
 def css_to_xpath(query: str, prefix: str = "descendant-or-self::") -> str:
     """convert css to XPATH selector"""
@@ -24,6 +30,10 @@ def xpath_to_css(query: str) -> str:
     EG FAIL:
         //p[contains(@class, "star-rating")]
 
+
+    NOTE:
+        cssselect not fully support CSS4 standard
+
     """
     # https://stackoverflow.com/a/18421383
     css = re.sub(
@@ -41,8 +51,8 @@ def xpath_to_css(query: str) -> str:
 
 def validate_css_query(query: str) -> None:
     try:
-        HTMLTranslator().css_to_xpath(query.strip('"'))
-    except SelectorSyntaxError:
+        css_compile(query.strip('"'))
+    except SoupSieveSelectorSyntaxError:
         # maybe is XPATH?
         with suppress(XPathSyntaxError):
             etree.XPath(query)  # type: ignore
@@ -57,10 +67,9 @@ def validate_xpath_query(query: str) -> None:
         etree.XPath(query.strip('"'))
         # etree.XPath accept CSS-like queries without throw exception, check it!
         is_css = False
-        with suppress(SelectorSyntaxError):
-            HTMLTranslator().css_to_xpath(query.strip('"'))
+        with suppress(SoupSieveSelectorSyntaxError):
+            css_compile(query.strip('"'))
             is_css = True
-
         if is_css:
             msg = f"`{query}` looks like CSS query, not XPATH"
             raise SelectorSyntaxError(msg)

{ssc_codegen-0.8.4 → ssc_codegen-0.8.6}/ssc_codegen/static_checker/base.py

@@ -62,7 +62,9 @@ FMT_MAPPING_METHODS = {
     TokenType.IS_CONTAINS: "is_contains",
     TokenType.IS_CSS: "is_css",
     TokenType.IS_XPATH: "is_xpath",
-    TokenType.IS_REGEX_MATCH: "is_regex",
+    TokenType.IS_STRING_REGEX_MATCH: "is_regex",
+    TokenType.ANY_LIST_STRING_REGEX_MATCH: "any_is_re",
+    TokenType.ALL_LIST_STRING_REGEX_MATCH: "all_is_re",
     TokenType.TO_INT: "to_int",
     TokenType.TO_INT_LIST: "to_int",
     TokenType.TO_FLOAT: "to_float",

{ssc_codegen-0.8.4 → ssc_codegen-0.8.6}/ssc_codegen/static_checker/callbacks.py

@@ -329,7 +329,7 @@ def analyze_regex_expr(
             case (
                 TokenType.EXPR_REGEX_SUB
                 | TokenType.EXPR_LIST_REGEX_SUB
-                | TokenType.IS_REGEX_MATCH
+                | TokenType.IS_STRING_REGEX_MATCH
             ):
                 result = analyze_re_expression(
                     re_expr.kwargs["pattern"], allow_empty_groups=True

{ssc_codegen-0.8.4 → ssc_codegen-0.8.6}/ssc_codegen/tokens.py

@@ -153,7 +153,9 @@ class TokenType(IntEnum):
     IS_CONTAINS = auto()
     IS_CSS = auto()
     IS_XPATH = auto()
-    IS_REGEX_MATCH = auto()
+    IS_STRING_REGEX_MATCH = auto()
+    ANY_LIST_STRING_REGEX_MATCH = auto()
+    ALL_LIST_STRING_REGEX_MATCH = auto()
 
     # NUMERIC
     TO_INT = auto()
@@ -186,7 +188,7 @@ class TokenType(IntEnum):
             TokenType.IS_EQUAL,
             TokenType.IS_NOT_EQUAL,
             TokenType.IS_CONTAINS,
-            TokenType.IS_REGEX_MATCH,
+            TokenType.IS_STRING_REGEX_MATCH,
         )
 
     @classmethod
@@ -196,5 +198,5 @@ class TokenType(IntEnum):
             TokenType.EXPR_REGEX_ALL,
             TokenType.EXPR_REGEX_SUB,
             TokenType.EXPR_LIST_REGEX_SUB,
-            TokenType.IS_REGEX_MATCH,
+            TokenType.IS_STRING_REGEX_MATCH,
         )