ssc_codegen 0.26.0__tar.gz → 0.26.2__tar.gz

{ssc_codegen-0.26.0 → ssc_codegen-0.26.2}/PKG-INFO

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

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

{ssc_codegen-0.26.0 → ssc_codegen-0.26.2}/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.0 → ssc_codegen-0.26.2}/ssc_codegen/converters/py_helpers.py

@@ -10,9 +10,21 @@ import ssc_codegen.ast as a
 from ssc_codegen.ast.struct import PlaceholderSpec
 
 from ssc_codegen.converters.base import ConverterContext
+import sys
+
 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.0 → ssc_codegen-0.26.2}/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.0 → ssc_codegen-0.26.2}/ssc_codegen/converters/py_parsel.py

@@ -30,6 +30,7 @@ def pre_imports(node: a.Imports, _: ConverterContext):
     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))
+    base_imports.extend(py_helpers.NOT_REQUIRED_IMPORT)
 
     transform_imports = sorted(node.transform_imports.get("py", set()))
 

{ssc_codegen-0.26.0 → ssc_codegen-0.26.2}/ssc_codegen/converters/py_slax.py

@@ -29,6 +29,7 @@ def pre_imports(node: a.Imports, _: ConverterContext):
     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))
+    base_imports.extend(py_helpers.NOT_REQUIRED_IMPORT)
 
     transform_imports = sorted(node.transform_imports.get("py", set()))
 

{ssc_codegen-0.26.0 → ssc_codegen-0.26.2}/ssc_codegen/core/expressions.py

@@ -438,6 +438,9 @@ def parse_expressions(
         lint.push(node.name)
         lint_pipeline_op(node, lint)
         expr = handler(node, parent, ctx, lint)  # type: ignore[assignment,arg-type]
+        if expr is None:
+            lint.pop()
+            continue
         if isinstance(expr, Fallback):
             lint.pop()
             continue
@@ -920,7 +923,12 @@ def _expr_jsonify(
     )
     json_def = ctx.json_defs.get(schema_name)
     if json_def is None:
-        raise ParseError(f"jsonify: JSON schema '{schema_name}' not found")
+        lint.error(
+            node,
+            message=f"jsonify: JSON schema '{schema_name}' not found",
+            code="E300",
+        )
+        return None
     ret_type, is_array = resolve_jsonify_type(json_def, path, ctx)
     return Jsonify(
         parent=parent,
@@ -938,7 +946,12 @@ def _expr_nested(
     struct_name = str(node.args[0].value)
     struct = ctx.structs.get(struct_name)
     if struct is None:
-        raise ParseError(f"nested: struct '{struct_name}' not found")
+        lint.error(
+            node,
+            message=f"nested: struct '{struct_name}' not found",
+            code="E300",
+        )
+        return None
     is_array = struct.struct_type in (StructType.FLAT, StructType.LIST)
     return Nested(parent=parent, struct_name=struct_name, is_array=is_array)
 

{ssc_codegen-0.26.0 → ssc_codegen-0.26.2}/ssc_codegen/core/module_handler.py

@@ -12,7 +12,7 @@ from ssc_codegen.ast import (
     TransformDef,
     TransformTarget,
 )
-from ssc_codegen.exceptions import BuildTimeError, ParseError
+from ssc_codegen.exceptions import BuildTimeError
 from ssc_codegen.kdl import (
     KDL2CSTParser,
     KdlArg,
@@ -142,13 +142,19 @@ def handle_transform(
         ).value
     )
     if accept_str not in _VAR_TYPE_MAP:
-        raise ParseError(
-            f"transform '{name}': invalid accept type '{accept_str}' (AUTO not allowed)"
+        lint.error(
+            node,
+            message=f"transform '{name}': invalid accept type '{accept_str}' (AUTO not allowed)",
+            code="E002",
         )
+        return
     if ret_str not in _VAR_TYPE_MAP:
-        raise ParseError(
-            f"transform '{name}': invalid return type '{ret_str}' (AUTO not allowed)"
+        lint.error(
+            node,
+            message=f"transform '{name}': invalid return type '{ret_str}' (AUTO not allowed)",
+            code="E002",
         )
+        return
     accept_type = _VAR_TYPE_MAP[accept_str]
     ret_type = _VAR_TYPE_MAP[ret_str]
     transform_def = TransformDef(name=name, accept=accept_type, ret=ret_type)

{ssc_codegen-0.26.0 → ssc_codegen-0.26.2}/ssc_codegen/core/reader.py

@@ -6,13 +6,17 @@ from collections.abc import Mapping
 from pathlib import Path
 
 from ssc_codegen.ast import Module
+from ssc_codegen.exceptions import BuildTimeError, ParseError
 from ssc_codegen.kdl import (
     KDL2CSTParser,
+    KDLParseError,
     KdlArg,
     KdlNode,
+    Position,
     ReadDiagnostic,
     Reader,
     Severity,
+    Span,
     WalkContext,
     parse_into,
 )
@@ -128,6 +132,34 @@ def parse_module(
 ) -> tuple[Module, list[ReadDiagnostic]]:
     """Parse KDL source -> Module AST + diagnostics."""
     parser = KDL2CSTParser()
-    doc = parser.parse(src)
+    try:
+        doc = parser.parse(src)
+    except KDLParseError as exc:
+        pos = Position(offset=exc.offset, line=exc.line, column=exc.column)
+        span = Span(start=pos, end=pos)
+        return Module(), [
+            ReadDiagnostic(
+                message=exc.message,
+                severity=Severity.ERROR,
+                span=span,
+                path=str(source_path) if source_path else "",
+                hint="Fix the syntax error and try again.",
+                code="E000",
+                label="syntax error",
+            )
+        ]
     reader = SscReader(source_path=source_path)
-    return parse_into(doc, reader)
+    try:
+        return parse_into(doc, reader)
+    except (ParseError, BuildTimeError) as exc:
+        pos = Position(offset=0, line=0, column=0)
+        span = Span(start=pos, end=pos)
+        return Module(), [
+            ReadDiagnostic(
+                message=str(exc),
+                severity=Severity.ERROR,
+                span=span,
+                path=str(source_path) if source_path else "",
+                code="E000",
+            )
+        ]

{ssc_codegen-0.26.0 → ssc_codegen-0.26.2}/ssc_codegen/core/struct_parser.py

@@ -27,7 +27,6 @@ from ssc_codegen.ast import (
     Value,
     VariableType,
 )
-from ssc_codegen.exceptions import ParseError
 from ssc_codegen.kdl import KdlArg, KdlNode
 
 from ssc_codegen.core.contexts import LintContext, ParseContext, WalkCtx
@@ -56,9 +55,12 @@ def parse_struct(
             parent.body.append(expr)
         elif node.name == "@check":
             if not node.args:
-                raise ParseError(
-                    "@check requires a name: @check <name> { ... }"
+                lint.error(
+                    node,
+                    message="@check requires a name: @check <name> { ... }",
+                    code="E001",
                 )
+                continue
             check_name = str(node.args[0].value)
             expr = CheckMethod(parent=parent, name=check_name)
             parse_expressions(node.children, expr, ctx, lint)
@@ -89,9 +91,12 @@ def parse_struct(
             parent.body.append(expr)
         elif node.name == "@request":
             if not node.args:
-                raise ParseError(
-                    "@request requires a multiline string argument"
+                lint.error(
+                    node,
+                    message="@request requires a multiline string argument",
+                    code="E001",
                 )
+                continue
             raw_payload = str(
                 ctx.property_defines.get(node.args[0].value, node.args[0].value)
             )
@@ -135,14 +140,22 @@ def parse_struct(
             parent.body.append(req)
         elif node.name == "@error":
             if not node.args or len(node.args) < 2:
-                raise ParseError("@error requires both status and schema name")
+                lint.error(
+                    node,
+                    message="@error requires both status and schema name",
+                    code="E001",
+                )
+                continue
             status_raw = node.args[0].value
             try:
                 status_int = int(status_raw)
             except (TypeError, ValueError):
-                raise ParseError(
-                    f"@error status must be integer, got {status_raw!r}"
+                lint.error(
+                    node,
+                    message=f"@error status must be integer, got {status_raw!r}",
+                    code="E002",
                 )
+                continue
             schema_name = str(
                 ctx.property_defines.get(node.args[1].value, node.args[1].value)
             )

{ssc_codegen-0.26.0 → ssc_codegen-0.26.2}/ssc_codegen/main.py

@@ -270,7 +270,9 @@ def generate(
             if skip_lint:
                 pass
             else:
-                lint_output = format_diagnostics(err, fmt=fmt.value)
+                lint_output = format_diagnostics(
+                    err, filepath=kdl_file, fmt=fmt.value
+                )
                 if lint_output:
                     typer.echo(lint_output, err=True)
                     errors.append(lint_output)
@@ -377,9 +379,9 @@ def check(
 
         if errs:
             total_errors += len(errs)
-            # TODO: json output
-            for e in format_diagnostics(errs, fmt=fmt.value):
-                typer.echo(e, err=True)
+            output = format_diagnostics(errs, filepath=kdl_file, fmt=fmt.value)
+            if output:
+                typer.echo(output, err=True)
 
     if total_errors > 0:
         if fmt == FmtType.TEXT:
@@ -495,9 +497,10 @@ def run(
             kdl_path.read_text(encoding="utf-8"), source_path=kdl_path
         )
         if errs:
-            for e in format_diagnostics(errs, fmt=fmt.value):
-                typer.echo(e, err=True)
-                raise typer.Exit(1)
+            output = format_diagnostics(errs, filepath=kdl_path, fmt=fmt.value)
+            if output:
+                typer.echo(output, err=True)
+            raise typer.Exit(1)
 
     except Exception as exc:
         if verbose: