ssc_codegen 0.8.5__tar.gz → 0.8.6__tar.gz

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

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

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

@@ -1,6 +1,6 @@
 [project]
 name = "ssc_codegen"
-version = "0.8.5"
+version = "0.8.6"
 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.6}/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.6"
 
 
 class __MISSING(object):

{ssc_codegen-0.8.5 → 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.5 → 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.5 → 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.5 → 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 (
@@ -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.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.5 → 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.5 → 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.5 → 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.5 → 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.5 → 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,
         )