ssc_codegen 0.8.2__tar.gz → 0.8.4__tar.gz

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

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

@@ -1,6 +1,6 @@
 [project]
 name = "ssc_codegen"
-version = "0.8.2"
+version = "0.8.4"
 description = "Python-dsl code converter to html parser for web scraping "
 readme = "README.md"
 requires-python = ">=3.10"
@@ -84,3 +84,26 @@ exclude = [
 [[tool.mypy.overrides]]
 module="tests.*"
 disallow_untyped_defs = false
+
+
+[tool.coverage.report]
+exclude_also = [
+    'def __repr__',
+    'if self.debug:',
+    'if settings.DEBUG',
+    'raise AssertionError',
+    'raise NotImplementedError',
+    'if 0:',
+    'if __name__ == .__main__.:',
+    'if TYPE_CHECKING:',
+    'class .*\bProtocol\):',
+    '@(abc\.)?abstractmethod',
+]
+
+[tool.coverage.run]
+source = ["ssc_codegen"]
+omit = [
+    "*/.venv/*",
+    "*/scripts/*",
+    "*/tests/*"
+]

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

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

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

@@ -1,5 +1,6 @@
 import json
 import logging
+import sys
 from pathlib import Path
 from types import ModuleType
 from typing import Any, Type
@@ -87,10 +88,16 @@ def extract_json_structs_from_module(module: ModuleType) -> list[Type[Json]]:
     ]
 
 
-def exec_module_code(path: str | Path) -> ModuleType:
+def exec_module_code(path: str | Path, add_sys_path: bool = True) -> ModuleType:
+    # apologize, input - real python file
     if isinstance(path, str):
         path = Path(path)
     module = ModuleType("_")
-    code = Path(path.resolve()).read_text()
+    abs_path = path.resolve()
+    # required for correct imports (eg: constants)
+    if add_sys_path and str(abs_path.parent) not in sys.path:
+        sys.path.append(str(abs_path.parent))
+
+    code = Path(abs_path).read_text()
     exec(code, module.__dict__)
     return module

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

@@ -673,9 +673,9 @@ def pre_str_regex(node: ExprStringRegex) -> str:
     if ignore_case:
         return (
             indent
-            + f"{nxt} = re.search(r{pattern!r}, {prv}, re.IGNORECASE)[{group}]"
+            + f"{nxt} = re.search({pattern!r}, {prv}, re.IGNORECASE)[{group}]"
         )
-    return indent + f"{nxt} = re.search(r{pattern!r}, {prv})[{group}]"
+    return indent + f"{nxt} = re.search({pattern!r}, {prv})[{group}]"
 
 
 def pre_str_regex_all(node: ExprStringRegexAll) -> str:
@@ -685,10 +685,8 @@ def pre_str_regex_all(node: ExprStringRegexAll) -> str:
     prv, nxt = prev_next_var(node)
     pattern, ignore_case = node.unpack_args()
     if ignore_case:
-        return (
-            indent + f"{nxt} = re.findall(r{pattern!r}, {prv}, re.IGNORECASE)"
-        )
-    return indent + f"{nxt} = re.findall(r{pattern!r}, {prv})"
+        return indent + f"{nxt} = re.findall({pattern!r}, {prv}, re.IGNORECASE)"
+    return indent + f"{nxt} = re.findall({pattern!r}, {prv})"
 
 
 def pre_str_regex_sub(node: ExprStringRegexSub) -> str:
@@ -697,7 +695,7 @@ def pre_str_regex_sub(node: ExprStringRegexSub) -> str:
     )
     prv, nxt = prev_next_var(node)
     pattern, repl = node.unpack_args()
-    return indent + f"{nxt} = re.sub(r{pattern!r}, {repl!r}, {prv})"
+    return indent + f"{nxt} = re.sub({pattern!r}, {repl!r}, {prv})"
 
 
 def pre_list_str_regex_sub(node: ExprListStringRegexSub) -> str:
@@ -706,9 +704,7 @@ def pre_list_str_regex_sub(node: ExprListStringRegexSub) -> str:
     )
     prv, nxt = prev_next_var(node)
     pattern, repl = node.unpack_args()
-    return (
-        indent + f"{nxt} = [re.sub(r{pattern!r}, {repl!r}, i) for i in {prv}]"
-    )
+    return indent + f"{nxt} = [re.sub({pattern!r}, {repl!r}, i) for i in {prv}]"
 
 
 def pre_index(node: ExprIndex) -> str:
@@ -780,7 +776,7 @@ def pre_is_regex(node: ExprIsRegex) -> str:
     )
     prv, nxt = prev_next_var(node)
     pattern, ignore_case, msg = node.unpack_args()
-    expr = indent + f"assert re.search(r{pattern!r}, {prv}), {msg!r}"
+    expr = indent + f"assert re.search({pattern!r}, {prv}), {msg!r}"
     if is_last_var_no_ret(node):
         return expr
     # HACK: avoid recalc variables

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

@@ -654,7 +654,6 @@ 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)
 

{ssc_codegen-0.8.2 → ssc_codegen-0.8.4}/ssc_codegen/schema.py

@@ -86,7 +86,9 @@ class BaseSchema:
             ].kwargs["schema_name"]
             signature[key] = cls.__NESTED_SCHEMAS__[name].__class_signature__()
         elif field.stack_last_ret == VariableType.JSON:
-            name = [e for e in field.stack if e.kind == TokenType.TO_JSON][0].kwargs["json_struct_name"]
+            name = [e for e in field.stack if e.kind == TokenType.TO_JSON][
+                0
+            ].kwargs["json_struct_name"]
             json_cls = cls.__JSON_SCHEMAS__[name]
             signature[key] = json_struct_to_signature(json_cls)
         else:

{ssc_codegen-0.8.2 → ssc_codegen-0.8.4}/ssc_codegen/str_utils.py

@@ -144,11 +144,23 @@ def py_optimize_return_naive(py_code: str) -> str:
     tmp_code = py_code
     for method_block in RE_PY_METHOD_BLOCK.finditer(tmp_code):
         ret_var = method_block["ret_var"]
-        # value6\s*=\s*(?P<expr>.*)$
+        # v6\s*=\s*(?P<expr>.*)$
         re_expr = f"{ret_var}\\s*=\\s*(?P<expr>.*)"
         if match := re.search(re_expr, method_block[0]):
             expr = match["expr"]  # noqa
 
+            # optimization function convert double backslash to single (\\ -> \) in regex patterns
+            # add `r` prefix for avoid SyntaxWarning then compile generated code to cpython bytecode
+            def add_r_prefix(m: re.Match) -> str:
+                func, string = m.groups()
+                if not string.startswith(('r"', "r'")):
+                    return f"{func}r{string}"
+                return match.group(0)
+
+            # in patterns codegen used single quotas literals
+            expr = re.sub(
+                r'(\bre\.\w+\()\s*(".*?"|\'.*?\')', add_r_prefix, expr
+            )
             new_method_block = re.sub(f"\\s*{re_expr}", "", method_block[0])
             new_method_block = re.sub(
                 rf"return {ret_var}", f"return {expr}", new_method_block