ssc_codegen 0.26.1__tar.gz → 0.26.3__tar.gz

{ssc_codegen-0.26.1 → ssc_codegen-0.26.3}/PKG-INFO

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

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

{ssc_codegen-0.26.1 → ssc_codegen-0.26.3}/ssc_codegen/converters/py_bs4.py

@@ -62,12 +62,8 @@ def pre_imports(node: a.Imports, ctx: ConverterContext):
             "import re",
             "import sys",
             "from typing import TypedDict, Optional, Any, List, Dict, Union, Literal",
-            "",
-            "if sys.version_info >= (3, 11):",
-            "    from typing import NotRequired",
-            "else:",
-            "    from typing_extensions import NotRequired",
         ]
+        base_imports.extend(py_helpers.NOT_REQUIRED_IMPORT)
     else:
         base_imports = [
             "import json",
@@ -77,15 +73,7 @@ def pre_imports(node: a.Imports, ctx: ConverterContext):
         ]
         if not py_helpers.module_is_rest_only(node):
             base_imports.append("from html import unescape as _html_unescape")
-        base_imports.extend(
-            [
-                "",
-                "if sys.version_info >= (3, 11):",
-                "    from typing import NotRequired",
-                "else:",
-                "    from typing_extensions import NotRequired",
-            ]
-        )
+        base_imports.extend(py_helpers.NOT_REQUIRED_IMPORT)
         base_imports.extend(py_helpers.rest_imports(node))
 
     # Get transform imports for Python (already collected during parsing)

{ssc_codegen-0.26.1 → ssc_codegen-0.26.3}/ssc_codegen/converters/py_helpers.py

@@ -10,9 +10,20 @@ import ssc_codegen.ast as a
 from ssc_codegen.ast.struct import PlaceholderSpec
 
 from ssc_codegen.converters.base import ConverterContext
+
 from ssc_codegen.converters.helpers import to_pascal_case
 
+NOT_REQUIRED_IMPORT: list[str] = [
+    "",
+    "if sys.version_info >= (3, 11):",
+    "    from typing import NotRequired",
+    "else:",
+    "    from typing_extensions import NotRequired",
+]
+
 __all__ = [
+    # Shared import fragments
+    "NOT_REQUIRED_IMPORT",
     # Runtime module generation
     "base_utility_lines",
     "runtime_export_names",

{ssc_codegen-0.26.1 → ssc_codegen-0.26.3}/ssc_codegen/converters/py_lxml.py

@@ -49,6 +49,8 @@ def pre_imports(node: a.Imports, ctx: ConverterContext):
             base_imports.append("from html import unescape as _html_unescape")
         base_imports.extend(py_helpers.rest_imports(node))
 
+    base_imports.extend(py_helpers.NOT_REQUIRED_IMPORT)
+
     # Get transform imports for Python (already collected during parsing)
     transform_imports = sorted(node.transform_imports.get("py", set()))
 

{ssc_codegen-0.26.1 → ssc_codegen-0.26.3}/ssc_codegen/converters/py_parsel.py

@@ -21,15 +21,27 @@ PY_TYPES[VT.LIST_DOCUMENT] = "SelectorList"
 
 
 @PY_PARSEL_CONVERTER(a.Imports)
-def pre_imports(node: a.Imports, _: ConverterContext):
-    base_imports = [
-        "import re",
-        "import sys",
-        "from typing import TypedDict, Optional, Any, List, Dict, Union, Literal",
-    ]
-    if not py_helpers.module_is_rest_only(node):
-        base_imports.append("from html import unescape as _html_unescape")
-    base_imports.extend(py_helpers.rest_imports(node))
+def pre_imports(node: a.Imports, ctx: ConverterContext):
+    runtime = ctx.meta.get("runtime_module")
+    if runtime:
+        base_imports = [
+            "import json",
+            "import re",
+            "import sys",
+            "from typing import TypedDict, Optional, Any, List, Dict, Union, Literal",
+        ]
+        base_imports.extend(py_helpers.NOT_REQUIRED_IMPORT)
+    else:
+        base_imports = [
+            "import json",
+            "import re",
+            "import sys",
+            "from typing import TypedDict, Optional, Any, List, Dict, Union, Literal",
+        ]
+        if not py_helpers.module_is_rest_only(node):
+            base_imports.append("from html import unescape as _html_unescape")
+        base_imports.extend(py_helpers.NOT_REQUIRED_IMPORT)
+        base_imports.extend(py_helpers.rest_imports(node))
 
     transform_imports = sorted(node.transform_imports.get("py", set()))
 

{ssc_codegen-0.26.1 → ssc_codegen-0.26.3}/ssc_codegen/converters/py_slax.py

@@ -20,15 +20,27 @@ PY_TYPES[VT.LIST_DOCUMENT] = "List[Node]"
 
 
 @PY_SLAX_CONVERTER(a.Imports)
-def pre_imports(node: a.Imports, _: ConverterContext):
-    base_imports = [
-        "import re",
-        "import sys",
-        "from typing import TypedDict, Optional, Any, List, Dict, Union, Literal",
-    ]
-    if not py_helpers.module_is_rest_only(node):
-        base_imports.append("from html import unescape as _html_unescape")
-    base_imports.extend(py_helpers.rest_imports(node))
+def pre_imports(node: a.Imports, ctx: ConverterContext):
+    runtime = ctx.meta.get("runtime_module")
+    if runtime:
+        base_imports = [
+            "import json",
+            "import re",
+            "import sys",
+            "from typing import TypedDict, Optional, Any, List, Dict, Union, Literal",
+        ]
+        base_imports.extend(py_helpers.NOT_REQUIRED_IMPORT)
+    else:
+        base_imports = [
+            "import json",
+            "import re",
+            "import sys",
+            "from typing import TypedDict, Optional, Any, List, Dict, Union, Literal",
+        ]
+        if not py_helpers.module_is_rest_only(node):
+            base_imports.append("from html import unescape as _html_unescape")
+        base_imports.extend(py_helpers.NOT_REQUIRED_IMPORT)
+        base_imports.extend(py_helpers.rest_imports(node))
 
     transform_imports = sorted(node.transform_imports.get("py", set()))
 

{ssc_codegen-0.26.1 → ssc_codegen-0.26.3}/ssc_codegen/core/expressions.py

@@ -74,7 +74,7 @@ from ssc_codegen.ast import (
     XpathSelect,
     XpathSelectAll,
 )
-from ssc_codegen.exceptions import BuildTimeError, ParseError
+from ssc_codegen.exceptions import BuildTimeError
 from ssc_codegen.kdl import KdlArg, KdlNode
 from ssc_codegen.regex_utils import normalize_regex_pattern
 from typing import cast

{ssc_codegen-0.26.1 → ssc_codegen-0.26.3}/ssc_codegen/main.py

@@ -260,16 +260,16 @@ def generate(
         meta["_include_fallback_html"] = target == Target.PY_LXML
         register_runtime_file(converter, _runtime_name)
 
+    # Phase 1: parse all KDL files
+    from ssc_codegen.ast import Module, Struct
+
+    parsed: list[tuple[Path, Module]] = []
     for kdl_file in kdl_files:
-        out_file = output / kdl_file.with_suffix(ext).name
-        logger.debug("processing: %s -> %s", kdl_file, out_file)
         try:
             ast, err = parse_module(
                 kdl_file.read_text(encoding="utf-8"), source_path=kdl_file
             )
-            if skip_lint:
-                pass
-            else:
+            if not skip_lint:
                 lint_output = format_diagnostics(
                     err, filepath=kdl_file, fmt=fmt.value
                 )
@@ -278,18 +278,42 @@ def generate(
                     errors.append(lint_output)
                     continue
             logger.debug("AST built for %s", kdl_file)
-
-            if converter.has_support_files:
-                generated: dict[str, str] = converter.convert_all(ast, **meta)
-                for name, content in generated.items():
-                    target_path = out_file if name == "" else output / name
-                    target_path.write_text(content, encoding="utf-8")
-                    if name:
-                        typer.echo(f"  -> {target_path}")
-                code = generated[""]
+            parsed.append((kdl_file, ast))
+        except Exception as exc:
+            if verbose:
+                typer.echo(traceback.format_exc(), err=True)
             else:
-                code = converter.convert(ast, **meta)
-                out_file.write_text(code, encoding="utf-8")
+                typer.echo(f"  ERROR {kdl_file}: {exc}", err=True)
+            errors.append(str(kdl_file))
+
+    # Phase 2: write runtime file once (if -R is used)
+    if separate_runtime and parsed:
+        from ssc_codegen.converters.py_helpers import runtime_module_content
+
+        include_fallback = target == Target.PY_LXML
+        # Pick an AST that has REST structs so the runtime includes helpers
+        ref_ast = next(
+            (
+                ast
+                for _, ast in parsed
+                if any(isinstance(n, Struct) and n.is_rest for n in ast.body)
+            ),
+            parsed[0][1],
+        )
+        runtime_path = output / f"{_runtime_name}.py"
+        runtime_path.write_text(
+            runtime_module_content(ref_ast, include_fallback),
+            encoding="utf-8",
+        )
+        typer.echo(f"  -> {runtime_path}")
+
+    # Phase 3: generate and write each main module
+    for kdl_file, ast in parsed:
+        out_file = output / kdl_file.with_suffix(ext).name
+        logger.debug("processing: %s -> %s", kdl_file, out_file)
+        try:
+            code = converter.convert(ast, **meta)
+            out_file.write_text(code, encoding="utf-8")
 
             logger.debug(
                 "code generated for %s (%d chars)", kdl_file, len(code)