ssc_codegen 0.7.4__tar.gz → 0.7.6__tar.gz

{ssc_codegen-0.7.4 → ssc_codegen-0.7.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ssc_codegen
-Version: 0.7.4
+Version: 0.7.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.7.4 → ssc_codegen-0.7.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ssc_codegen"
-version = "0.7.4"
+version = "0.7.6"
 description = "Python-dsl code converter to html parser for web scraping "
 readme = "README.md"
 requires-python = ">=3.10"
@@ -26,7 +26,6 @@ classifiers = [
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
-
 ]
 
 [project.urls]

{ssc_codegen-0.7.4 → ssc_codegen-0.7.6}/ssc_codegen/__init__.py

@@ -3,7 +3,7 @@ from .document import HTMLDocument, StringDocument, ArrayDocument, AssertDocumen
 from .json_struct import Json
 from .schema import ItemSchema, DictSchema, ListSchema, FlatListSchema
 
-VERSION = "0.7.4"
+VERSION = "0.7.6"
 
 class __MISSING(object):
     pass

{ssc_codegen-0.7.4 → ssc_codegen-0.7.6}/ssc_codegen/ast_build_utils.py

@@ -126,6 +126,10 @@ def extract_json_structs_from_module(module: ModuleType) -> list[Type[Json]]:
 def assert_ret_type_not_document(
     field: "BaseDocument", name: str, schema: Type[BaseSchema]
 ) -> None:
+    # always ret nil, skip
+    if name == "__PRE_VALIDATE__":
+        return
+
     if field.stack_last_ret == VariableType.DOCUMENT:
         msg = f"{schema.__name__}.{name} cannot return type {VariableType.DOCUMENT.name}"
         raise TypeError(msg)
@@ -222,6 +226,19 @@ def assert_field_document_variable_types(field: BaseDocument) -> None:
         if var_cursor == expr.accept_type:
             var_cursor = expr.ret_type
             continue
+        # currently used in to_len() operation
+        elif expr.accept_type == VariableType.LIST_ANY:
+            if var_cursor in (
+                VariableType.LIST_STRING,
+                VariableType.LIST_DOCUMENT,
+                VariableType.LIST_FLOAT,
+                VariableType.LIST_INT,
+            ):
+                var_cursor = expr.ret_type
+                continue
+            msg = f".to_len() expected LIST_ANY type, got '{var_cursor.name}'"
+            raise TypeError(msg)
+
         # this type always first (naive, used in DEFAULT and RETURN expr)
         elif expr.accept_type == VariableType.ANY:
             var_cursor = VariableType.DOCUMENT
@@ -232,5 +249,6 @@ def assert_field_document_variable_types(field: BaseDocument) -> None:
         elif var_cursor == VariableType.NESTED:
             raise TypeError("sub_parser not allowed next instructions")
 
+        # not covered cases
         msg = f"'{expr.kind.name}' expected type '{expr.accept_type.name}', got '{var_cursor.name}'"
         raise TypeError(msg)

{ssc_codegen-0.7.4 → ssc_codegen-0.7.6}/ssc_codegen/ast_ssc.py

@@ -427,12 +427,7 @@ class JoinExpression(BaseExpression):
 @dataclass(kw_only=True)
 class ArrayLengthExpression(BaseExpression):
     kind: ClassVar[TokenType] = TokenType.EXPR_LIST_LEN
-    accept_type: VariableType = (
-        VariableType.LIST_STRING
-        | VariableType.LIST_DOCUMENT
-        | VariableType.LIST_INT
-        | VariableType.LIST_FLOAT
-    )
+    accept_type: VariableType = VariableType.LIST_ANY
     ret_type: VariableType = VariableType.INT
 
 
@@ -664,6 +659,7 @@ class RegexExpression(BaseExpression):
     ret_type: VariableType = VariableType.STRING
     pattern: str
     group: int
+    ignore_case: bool = False
 
 
 @dataclass(kw_only=True)
@@ -683,6 +679,7 @@ class RegexAllExpression(BaseExpression):
     accept_type: VariableType = VariableType.STRING
     ret_type: VariableType = VariableType.LIST_STRING
     pattern: str
+    ignore_case: bool = False
 
 
 @dataclass(kw_only=True)
@@ -700,6 +697,7 @@ class RegexSubExpression(BaseExpression):
     ret_type: VariableType = VariableType.STRING
     pattern: str
     repl: str
+    ignore_case: bool = False
 
 
 @dataclass(kw_only=True)
@@ -849,6 +847,7 @@ class IsRegexMatchExpression(BaseExpression):
     ret_type: VariableType = VariableType.STRING
     pattern: str
     msg: str
+    ignore_case: bool = False
 
 
 @dataclass(kw_only=True)

{ssc_codegen-0.7.4 → ssc_codegen-0.7.6}/ssc_codegen/converters/py_base.py

@@ -401,7 +401,7 @@ def tt_regex(node: RegexExpression) -> str:
     prv, nxt = lr_var_names(variable=node.variable)
     pattern = repr(node.pattern)
     group = node.group
-    code = py.BINDINGS[node.kind, nxt, pattern, prv, group]
+    code = py.BINDINGS[node.kind, nxt, pattern, prv, group, node.ignore_case]
     return indent + code
 
 
@@ -410,7 +410,7 @@ def tt_regex_all(node: RegexAllExpression) -> str:
 
     prv, nxt = lr_var_names(variable=node.variable)
     pattern = repr(node.pattern)
-    code = py.BINDINGS[node.kind, nxt, pattern, prv]
+    code = py.BINDINGS[node.kind, nxt, pattern, prv, node.ignore_case]
     return indent + code
 
 
@@ -497,7 +497,7 @@ def tt_is_regex(node: IsRegexMatchExpression) -> str:
     pattern = repr(node.pattern)
     msg = repr(node.msg)
 
-    code = py.BINDINGS[node.kind, pattern, prv, msg]
+    code = py.BINDINGS[node.kind, pattern, prv, msg, node.ignore_case]
     if node.next.kind == TokenType.EXPR_NO_RETURN:
         return indent + code
     return indent + code + "\n" + indent + f"{nxt} = {prv}"

{ssc_codegen-0.7.4 → ssc_codegen-0.7.6}/ssc_codegen/converters/templates/py.py

@@ -103,9 +103,25 @@ BINDINGS[TokenType.EXPR_LIST_STRING_REPLACE] = (
     "{} = [e.replace({}, {}) for e in {}]"
 )
 BINDINGS[TokenType.EXPR_STRING_SPLIT] = "{} = {}.split({})"
+
+
 # regex
-BINDINGS[TokenType.EXPR_REGEX] = "{} = re.search({}, {})[{}]"
-BINDINGS[TokenType.EXPR_REGEX_ALL] = "{} = re.findall({}, {})"
+def expr_re(
+    nxt: str, pattern: str, prv: str, group: int, ignore_case: bool
+) -> str:
+    if ignore_case:
+        return f"{nxt} = re.search({pattern}, '{prv}', re.IGNORECASE)[{group}]"
+    return f"{nxt} = re.search({pattern}, '{prv}')[{group}]"
+
+
+def expr_re_all(nxt: str, pattern: str, prv: str, ignore_case: bool) -> str:
+    if ignore_case:
+        return f"{nxt} = re.findall({pattern}, '{prv}', re.IGNORECASE)"
+    return f"{nxt} = re.findall({pattern}, '{prv}')"
+
+
+BINDINGS[TokenType.EXPR_REGEX] = expr_re
+BINDINGS[TokenType.EXPR_REGEX_ALL] = expr_re_all
 BINDINGS[TokenType.EXPR_REGEX_SUB] = "{} = re.sub({}, {}, {})"
 BINDINGS[TokenType.EXPR_LIST_REGEX_SUB] = "{} = [re.sub({}, {}, e) for e in {}]"
 
@@ -118,7 +134,15 @@ BINDINGS[TokenType.EXPR_LIST_JOIN] = "{} = {}.join({})"
 BINDINGS[TokenType.IS_EQUAL] = "assert {} == {}, {}"
 BINDINGS[TokenType.IS_NOT_EQUAL] = "assert {} != {}, {}"
 BINDINGS[TokenType.IS_CONTAINS] = "assert {} in {}, {}"
-BINDINGS[TokenType.IS_REGEX_MATCH] = "assert re.search({}, {}), {}"
+
+
+def is_regex(pattern: str, prv: str, msg: str, ignore_case: bool) -> str:
+    if ignore_case:
+        return f"assert re.search({pattern}, {prv}, re.IGNORECASE), {msg}"
+    return f"assert re.search({pattern}, {prv}), {msg}"
+
+
+BINDINGS[TokenType.IS_REGEX_MATCH] = is_regex
 
 # int, float converters
 BINDINGS[TokenType.TO_INT] = "{} = int({})"

{ssc_codegen-0.7.4 → ssc_codegen-0.7.6}/ssc_codegen/document.py

@@ -51,7 +51,11 @@ from .ast_ssc import (
     ToBool,
     ArrayLengthExpression,
 )
-from .document_utlis import assert_re_expression, unverbosify_regex
+from .document_utlis import (
+    assert_re_expression,
+    unverbosify_regex,
+    is_ignore_case_regex,
+)
 from .schema import BaseSchema
 from .selector_utils import validate_css_query, validate_xpath_query
 from .tokens import VariableType
@@ -458,7 +462,9 @@ class StringDocument(BaseDocument):
                 )
         return self
 
-    def re(self, pattern: str | Pattern, group: int = 1) -> Self:
+    def re(
+        self, pattern: str | Pattern, group: int = 1, ignore_case: bool = False
+    ) -> Self:
         """extract first regex result.
 
         NOTE:
@@ -466,6 +472,10 @@ class StringDocument(BaseDocument):
 
         - accept STRING, return STRING
         """
+        # TODO: implement, js, go, dart ignorecase flag
+        if not isinstance(pattern, str):
+            ignore_case = is_ignore_case_regex(pattern)
+
         pattern = unverbosify_regex(pattern)
         assert_re_expression(pattern)
 
@@ -473,21 +483,28 @@ class StringDocument(BaseDocument):
             self._raise_wrong_type_error(
                 self.stack_last_ret, VariableType.STRING
             )
-        self._add(RegexExpression(pattern=pattern, group=group))
+        self._add(
+            RegexExpression(
+                pattern=pattern, group=group, ignore_case=ignore_case
+            )
+        )
         return self
 
-    def re_all(self, pattern: str | Pattern) -> Self:
+    def re_all(self, pattern: str | Pattern, ignore_case: bool = False) -> Self:
         """extract all regex results.
 
         - accept STRING, return LIST_STRING
         """
+        if not isinstance(pattern, str):
+            ignore_case = is_ignore_case_regex(pattern)
+
         pattern = unverbosify_regex(pattern)
         assert_re_expression(pattern, max_groups=1)
         if self.stack_last_ret != VariableType.STRING:
             self._raise_wrong_type_error(
                 self.stack_last_ret, VariableType.STRING
             )
-        self._add(RegexAllExpression(pattern=pattern))
+        self._add(RegexAllExpression(pattern=pattern, ignore_case=ignore_case))
         return self
 
     def re_sub(self, pattern: str | Pattern, repl: str = "") -> Self:
@@ -674,20 +691,29 @@ class AssertDocument(BaseDocument):
         self._add(IsContainsExpression(item=item, msg=msg))
         return self
 
-    def is_regex(self, pattern: str, msg: str = "") -> Self:
+    def is_regex(
+        self, pattern: str | Pattern, msg: str = "", ignore_case: bool = False
+    ) -> Self:
         """assert value matched by regex. If in generated code check failed - throw exception with passed msg
 
         EXPR DO NOT MODIFY variable
 
         - accept STRING, return STRING
         """
+        if not isinstance(pattern, str):
+            ignore_case = is_ignore_case_regex(pattern)
+        pattern = unverbosify_regex(pattern)
         if self.stack_last_ret != VariableType.STRING:
             self._raise_wrong_type_error(
                 self.stack_last_ret, VariableType.STRING
             )
         assert_re_expression(pattern, allow_empty_groups=True)
 
-        self._add(IsRegexMatchExpression(pattern=pattern, msg=msg))
+        self._add(
+            IsRegexMatchExpression(
+                pattern=pattern, msg=msg, ignore_case=ignore_case
+            )
+        )
         return self
 
 

{ssc_codegen-0.7.4 → ssc_codegen-0.7.6}/ssc_codegen/document_utlis.py

@@ -22,6 +22,12 @@ CM2_RX = r"(\\)?((\\{2})*)(#)"
 WS_RX = r"(\\)?((\\{2})*)(\s)\s*"
 
 
+def is_ignore_case_regex(pattern: str | Pattern) -> bool:
+    if isinstance(pattern, str):
+        return False
+    return bool(pattern.flags & re.IGNORECASE)
+
+
 def unverbosify_regex(pattern: str | Pattern) -> str:
     if isinstance(pattern, str):
         return pattern

{ssc_codegen-0.7.4 → ssc_codegen-0.7.6}/ssc_codegen/tokens.py

@@ -14,6 +14,10 @@ class VariableType(IntEnum):
     # mark accept any variable type
     # used in return and default expr
     ANY = auto()
+
+    # currently used for to_len() operation
+    LIST_ANY = auto()
+
     # nested functions
     NESTED = auto()
     INT = auto()