ssc_codegen 0.7.3__tar.gz → 0.7.5__tar.gz

{ssc_codegen-0.7.3 → ssc_codegen-0.7.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ssc_codegen
-Version: 0.7.3
+Version: 0.7.5
 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.3 → ssc_codegen-0.7.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ssc_codegen"
-version = "0.7.3"
+version = "0.7.5"
 description = "Python-dsl code converter to html parser for web scraping "
 readme = "README.md"
 requires-python = ">=3.10"
@@ -13,6 +13,7 @@ dependencies = [
     "typer>=0.15.1",
     "typing_extensions;python_version<'3.11'",
 ]
+
 classifiers = [
     "Development Status :: 3 - Alpha",
     "Environment :: Console",
@@ -25,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.3 → ssc_codegen-0.7.5}/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.3"
+VERSION = "0.7.5"
 
 class __MISSING(object):
     pass

{ssc_codegen-0.7.3 → ssc_codegen-0.7.5}/ssc_codegen/ast_ssc.py

@@ -664,6 +664,7 @@ class RegexExpression(BaseExpression):
     ret_type: VariableType = VariableType.STRING
     pattern: str
     group: int
+    ignore_case: bool = False
 
 
 @dataclass(kw_only=True)
@@ -683,6 +684,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 +702,7 @@ class RegexSubExpression(BaseExpression):
     ret_type: VariableType = VariableType.STRING
     pattern: str
     repl: str
+    ignore_case: bool = False
 
 
 @dataclass(kw_only=True)
@@ -849,6 +852,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.3 → ssc_codegen-0.7.5}/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.3 → ssc_codegen-0.7.5}/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.3 → ssc_codegen-0.7.5}/ssc_codegen/document.py

@@ -1,6 +1,6 @@
 """high-level AST builder interface"""
 
-from typing import Type
+from typing import Type, Pattern
 
 from typing_extensions import Self
 
@@ -51,7 +51,11 @@ from .ast_ssc import (
     ToBool,
     ArrayLengthExpression,
 )
-from .document_utlis import assert_re_expression
+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, group: int = 1) -> Self:
+    def re(
+        self, pattern: str | Pattern, group: int = 1, ignore_case: bool = False
+    ) -> Self:
         """extract first regex result.
 
         NOTE:
@@ -466,34 +472,48 @@ 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)
 
         if self.stack_last_ret != VariableType.STRING:
             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) -> 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, repl: str = "") -> Self:
+    def re_sub(self, pattern: str | Pattern, repl: str = "") -> Self:
         """Replace substring by `pattern` to `repl`.
 
         - accept STRING, return STRING
         - accept LIST_STRING, return LIST_STRING
         """
+        pattern = unverbosify_regex(pattern)
         assert_re_expression(pattern, allow_empty_groups=True)
 
         match self.stack_last_ret:
@@ -671,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.3 → ssc_codegen-0.7.5}/ssc_codegen/document_utlis.py

@@ -1,5 +1,5 @@
 import re
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Pattern
 
 from ssc_codegen.ast_ssc import (
     BaseExpression,
@@ -16,6 +16,46 @@ if TYPE_CHECKING:
     from .document import BaseDocument
 
 
+# https://stackoverflow.com/a/14919203
+CM1_RX = r"(?m)(?<!\\)((\\{2})*)#.*$"
+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
+
+    def strip_escapes(match):  # type: ignore
+        ## if even slashes: delete space and retain slashes
+        if match.group(1) is None:
+            return match.group(2)
+        ## if number of slashes is odd: delete slash and keep space (or 'comment')
+        elif match.group(1) == "\\":
+            return match.group(2) + match.group(4)
+        ## error
+        else:
+            raise Exception
+
+    if pattern.flags & re.X:
+        not_verbose_regex = re.sub(
+            WS_RX,
+            strip_escapes,
+            re.sub(
+                CM2_RX, strip_escapes, re.sub(CM1_RX, "\\1", pattern.pattern)
+            ),
+        )
+
+        return not_verbose_regex
+    return pattern.pattern
+
+
 def assert_re_expression(
     pattern: str, allow_empty_groups: bool = False, max_groups: int = -1
 ) -> None: