ssc_codegen 0.8.5__tar.gz → 0.8.7__tar.gz

{ssc_codegen-0.8.5 → ssc_codegen-0.8.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ssc_codegen
-Version: 0.8.5
+Version: 0.8.7
 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

{ssc_codegen-0.8.5 → ssc_codegen-0.8.7}/pyproject.toml

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

{ssc_codegen-0.8.5 → ssc_codegen-0.8.7}/ssc_codegen/__init__.py

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

{ssc_codegen-0.8.5 → ssc_codegen-0.8.7}/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.5 → ssc_codegen-0.8.7}/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.5 → ssc_codegen-0.8.7}/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.5 → ssc_codegen-0.8.7}/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 (
@@ -442,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
@@ -454,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.5 → ssc_codegen-0.8.7}/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.5 → ssc_codegen-0.8.7}/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.5 → ssc_codegen-0.8.7}/ssc_codegen/document.py

@@ -4,7 +4,7 @@ import logging
 from typing import Type, Pattern
 
 from cssselect import SelectorSyntaxError
-from typing_extensions import Self
+from typing_extensions import Self, assert_never
 
 from ssc_codegen.ast_ import (
     BaseAstNode,
@@ -41,7 +41,7 @@ from ssc_codegen.ast_ import (
     ExprIsEqual,
     ExprIsNotEqual,
     ExprIsContains,
-    ExprIsRegex,
+    ExprStringIsRegex,
     ExprNested,
     ExprToInt,
     ExprToListInt,
@@ -55,12 +55,19 @@ from ssc_codegen.ast_ import (
     ExprListStringRmSuffix,
     ExprStringRmPrefixAndSuffix,
     ExprListStringRmPrefixAndSuffix,
+    ExprListStringAllRegex,
+    ExprListStringAnyRegex,
 )
 from ssc_codegen.document_utlis import (
     analyze_re_expression,
     unverbosify_regex,
     is_ignore_case_regex,
 )
+from ssc_codegen.pseudo_selectors import (
+    parse_pseudo_xpath_query,
+    parse_pseudo_css_query,
+    PseudoAction,
+)
 from ssc_codegen.json_struct import Json
 from ssc_codegen.schema import BaseSchema
 from ssc_codegen.selector_utils import validate_css_query, validate_xpath_query
@@ -70,6 +77,8 @@ LOGGER = logging.getLogger("ssc_gen")
 
 
 class BaseDocument:
+    LOGGER = LOGGER
+
     def __init__(self) -> None:
         self._stack: list[BaseAstNode] = []
 
@@ -96,14 +105,6 @@ class BaseDocument:
             return VariableType.DOCUMENT
         return self.stack[-1].ret_type
 
-    @staticmethod
-    def _raise_wrong_type_error(
-        type_: VariableType, *expected: VariableType
-    ) -> None:
-        fmt_types = "(" + ",".join(i.name for i in expected) + ")"
-        msg = f"Expected type(s): {fmt_types}, got {type_.name}"
-        raise SyntaxError(msg)
-
     def _add(self, expr: BaseAstNode) -> None:
         self._stack.append(expr)
 
@@ -138,6 +139,7 @@ class HTMLDocument(BaseDocument):
         - accept: DOCUMENT, return DOCUMENT
         """
         query = " ".join(query.splitlines())
+        query, action = parse_pseudo_css_query(query)
         try:
             validate_css_query(query)
         except SelectorSyntaxError:
@@ -151,13 +153,29 @@ class HTMLDocument(BaseDocument):
             )
 
         self._add(ExprCss(kwargs={"query": query}))
+        self._pseudo_query_action_to_expr(action)
         return self
 
+    def _pseudo_query_action_to_expr(
+        self, action: tuple[PseudoAction | None, str | None]
+    ) -> None:
+        if action[0]:
+            match action[0]:
+                case "text":
+                    self.text()
+                case "raw":
+                    self.raw()
+                case "attr":
+                    self.attr(action[1])  # type: ignore
+                case _:
+                    assert_never(action[0])
+
     def xpath(self, query: str) -> Self:
         """Xpath query. returns first founded element
         - accept: DOCUMENT, return DOCUMENT
         """
         query = " ".join(query.splitlines())
+        query, action = parse_pseudo_xpath_query(query)
         try:
             validate_xpath_query(query)
         except SelectorSyntaxError:
@@ -170,22 +188,15 @@ class HTMLDocument(BaseDocument):
                 self.stack_last_ret.name,
             )
         self._add(ExprXpath(kwargs={"query": query}))
+        self._pseudo_query_action_to_expr(action)
         return self
-        # match self.stack_last_ret:
-        #     case VariableType.DOCUMENT:
-        #         self._add(HtmlXpathExpression(query=query))
-        #     case VariableType.ANY:
-        #         self._add(HtmlXpathExpression(query=query))
-        #     case _:
-        #         self._raise_wrong_type_error(
-        #             self.stack_last_ret, VariableType.DOCUMENT
-        #         )
 
     def css_all(self, query: str) -> Self:
         """Css query. returns all founded elements
         - accept: DOCUMENT, return: LIST_DOCUMENT
         """
         query = " ".join(query.splitlines())
+        query, action = parse_pseudo_css_query(query)
         try:
             validate_css_query(query)
         except SelectorSyntaxError:
@@ -197,6 +208,7 @@ class HTMLDocument(BaseDocument):
                 self.stack_last_ret.name,
             )
         self._add(ExprCssAll(kwargs={"query": query}))
+        self._pseudo_query_action_to_expr(action)
         return self
 
     def xpath_all(self, query: str) -> Self:
@@ -204,6 +216,7 @@ class HTMLDocument(BaseDocument):
         - accept: DOCUMENT, return: LIST_DOCUMENT
         """
         query = " ".join(query.splitlines())
+        query, action = parse_pseudo_xpath_query(query)
         try:
             validate_xpath_query(query)
         except SelectorSyntaxError as e:
@@ -215,6 +228,7 @@ class HTMLDocument(BaseDocument):
                 self.stack_last_ret.name,
             )
         self._add(ExprXpathAll(kwargs={"query": query}))
+        self._pseudo_query_action_to_expr(action)
         return self
 
     def attr(self, key: str) -> Self:
@@ -766,6 +780,13 @@ class AssertDocument(BaseDocument):
         - accept DOCUMENT, return DOCUMENT
         """
         query = " ".join(query.splitlines())
+        new_query, action = parse_pseudo_css_query(query)
+        if action[0]:
+            LOGGER.warning(
+                "is_css(%s) not support pseudo parse classes, skip", repr(query)
+            )
+            query = new_query
+
         try:
             validate_css_query(query)
         except SelectorSyntaxError:
@@ -788,6 +809,13 @@ class AssertDocument(BaseDocument):
         - accept DOCUMENT, return DOCUMENT
         """
         query = " ".join(query.splitlines())
+        new_query, action = parse_pseudo_xpath_query(query)
+        if action[0]:
+            LOGGER.warning(
+                "is_xpath(%s) not support pseudo parse classes, skip",
+                repr(query),
+            )
+            query = new_query
         try:
             validate_xpath_query(query)
         except SelectorSyntaxError:
@@ -953,6 +981,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 +1076,7 @@ class AssertDocument(BaseDocument):
             )
 
         self._add(
-            ExprIsRegex(
+            ExprStringIsRegex(
                 kwargs={
                     "pattern": pattern,
                     "ignore_case": ignore_case,

{ssc_codegen-0.8.5 → ssc_codegen-0.8.7}/ssc_codegen/document_utlis.py

@@ -1,6 +1,8 @@
+import logging
 import re
 from typing import TYPE_CHECKING, Pattern
-import logging
+from typing_extensions import assert_never
+
 from ssc_codegen.ast_ import (
     BaseAstNode,
     ExprIsCss,
@@ -10,6 +12,12 @@ from ssc_codegen.ast_ import (
     ExprXpath,
     ExprCssAll,
 )
+from ssc_codegen.pseudo_selectors import (
+    parse_pseudo_xpath_query,
+    pseudo_action_to_pseudo_xpath,
+    parse_pseudo_css_query,
+    pseudo_action_to_pseudo_css,
+)
 from ssc_codegen.selector_utils import css_to_xpath, xpath_to_css
 from ssc_codegen.static_checker.base import AnalyzeResult
 
@@ -18,7 +26,6 @@ LOGGER = logging.getLogger("ssc_gen")
 if TYPE_CHECKING:
     from .document import BaseDocument
 
-
 # https://stackoverflow.com/a/14919203
 CM1_RX = r"(?m)(?<!\\)((\\{2})*)#.*$"
 CM2_RX = r"(\\)?((\\{2})*)(#)"
@@ -88,35 +95,34 @@ def convert_css_to_xpath(
     new_stack: list[BaseAstNode] = []
 
     for expr in old_stack:
+        if expr.kind not in (ExprCss.kind, ExprCssAll.kind, ExprIsCss.kind):
+            new_stack.append(expr)
+            continue
+        query = expr.kwargs["query"]
+        query, pseudo_action = parse_pseudo_css_query(query)
+        new_query = css_to_xpath(query, prefix=prefix)
+        if pseudo_action[0]:
+            new_query += pseudo_action_to_pseudo_css(*pseudo_action)
         match expr.kind:
             case ExprCss.kind:
-                new_expr = ExprXpath(  # type: ignore[assignment]
-                    kwargs={
-                        "query": css_to_xpath(
-                            expr.kwargs["query"], prefix=prefix
-                        )
-                    }
-                )
+                new_stack.append(ExprXpath(kwargs={"query": new_query}))
             case ExprCssAll.kind:
-                new_expr = ExprXpathAll(  # type: ignore[assignment]
-                    kwargs={
-                        "query": css_to_xpath(
-                            expr.kwargs["query"], prefix=prefix
-                        )
-                    }
+                new_stack.append(
+                    ExprXpathAll(  # type: ignore[assignment]
+                        kwargs={"query": new_query}
+                    )
                 )
             case ExprIsCss.kind:
-                new_expr = ExprIsXpath(  # type: ignore[assignment]
-                    kwargs={
-                        "query": css_to_xpath(
-                            expr.kwargs["query"], prefix=prefix
-                        ),
-                        "msg": expr.kwargs["msg"],
-                    }
+                new_stack.append(
+                    ExprIsXpath(  # type: ignore[assignment]
+                        kwargs={
+                            "query": new_query,
+                            "msg": expr.kwargs["msg"],
+                        }
+                    )
                 )
             case _:
-                new_expr = expr  # type: ignore[assignment]
-        new_stack.append(new_expr)
+                assert_never(expr.kind)
     doc._stack = new_stack
     return doc
 
@@ -126,24 +132,33 @@ def convert_xpath_to_css(doc: "BaseDocument") -> "BaseDocument":
     old_stack = doc.stack.copy()
     new_stack: list[BaseAstNode] = []
     for expr in old_stack:
+        if expr.kind not in (
+            ExprXpath.kind,
+            ExprXpathAll.kind,
+            ExprIsXpath.kind,
+        ):
+            new_stack.append(expr)
+            continue
+        query = expr.kwargs["query"]
+        query, pseudo_action = parse_pseudo_xpath_query(query)
+        new_query = xpath_to_css(query)
+        if pseudo_action[0]:
+            new_query += pseudo_action_to_pseudo_xpath(*pseudo_action)
         match expr.kind:
             case ExprXpath.kind:
-                new_expr = ExprCss(
-                    kwargs={"query": xpath_to_css(expr.kwargs["query"])}
-                )
+                new_stack.append(ExprCss(kwargs={"query": new_query}))
             case ExprXpathAll.kind:
-                new_expr = ExprCssAll(  # type: ignore[assignment]
-                    kwargs={"query": xpath_to_css(expr.kwargs["query"])}
-                )
+                new_stack.append(ExprCssAll(kwargs={"query": new_query}))
             case ExprIsXpath.kind:
-                new_expr = ExprIsCss(  # type: ignore[assignment]
-                    kwargs={
-                        "query": xpath_to_css(expr.kwargs["query"]),
-                        "msg": expr.kwargs["msg"],
-                    }
+                new_stack.append(
+                    ExprIsCss(
+                        kwargs={
+                            "query": new_query,
+                            "msg": expr.kwargs["msg"],
+                        }
+                    )
                 )
             case _:
-                new_expr = expr  # type: ignore[assignment]
-        new_stack.append(new_expr)
+                assert_never(expr.kind)
     doc._stack = new_stack
     return doc

ssc_codegen-0.8.7/ssc_codegen/pseudo_selectors.py

@@ -0,0 +1,64 @@
+import re
+from typing import Literal
+
+PseudoAction = Literal["text", "raw", "attr"]
+
+
+def parse_pseudo_css_query(
+    query: str,
+) -> tuple[str, tuple[PseudoAction | None, str | None]]:
+    """parse css selector and extract pseudo class action"""
+    query = query.strip()
+
+    if query.endswith("::text"):
+        return query[: -len("::text")], ("text", None)
+
+    if query.endswith("::raw"):
+        return query[: -len("::raw")], ("raw", None)
+
+    if match := re.search(r"::attr\(([^)]+)\)$", query):
+        return query[: match.start()], ("attr", match.group(1))
+
+    return query, (None, None)
+
+
+def parse_pseudo_xpath_query(
+    query: str,
+) -> tuple[str, tuple[PseudoAction | None, str | None]]:
+    """parse xpath selector and extract pseudo class action"""
+    query = query.strip()
+
+    if query.endswith("/text()"):
+        return query[: -len("/text()")], ("text", None)
+
+    if query.endswith("/raw()"):
+        return query[: -len("/raw()")], ("raw", None)
+
+    if match := re.search(r"/@([\w:-]+)$", query):
+        return query[: match.start()], ("attr", match.group(1))
+
+    return query, (None, None)
+
+
+def pseudo_action_to_pseudo_css(action: PseudoAction, arg: str | None) -> str:
+    match action:
+        case "text":
+            return "::text"
+        case "raw":
+            return "::raw"
+        case "attr":
+            return f"::attr({arg})"
+        case _:
+            return ""
+
+
+def pseudo_action_to_pseudo_xpath(action: PseudoAction, arg: str | None) -> str:
+    match action:
+        case "text":
+            return "/text()"
+        case "raw":
+            return "/raw()"
+        case "attr":
+            return f"/@{arg}"
+        case _:
+            return ""

{ssc_codegen-0.8.5 → ssc_codegen-0.8.7}/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.5 → ssc_codegen-0.8.7}/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.5 → ssc_codegen-0.8.7}/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,
         )