ssc_codegen 0.32.3__tar.gz → 0.33.0__tar.gz

{ssc_codegen-0.32.3 → ssc_codegen-0.33.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ssc_codegen
-Version: 0.32.3
+Version: 0.33.0
 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
@@ -69,7 +69,7 @@ uv tool install ssc_codegen
 Generate Python parser:
 
 ```bash
-ssc-gen generate books.kdl -l python -L bs4 -o ./output
+ssc-gen generate python books.kdl -L bs4 -o ./output
 ```
 
 ## Usage
@@ -78,22 +78,25 @@ ssc-gen generate books.kdl -l python -L bs4 -o ./output
 
 ```bash
 # single file (Python + bs4)
-ssc-gen generate schema.kdl -l python -L bs4 -o ./output
+ssc-gen generate python schema.kdl -L bs4 -o ./output
 
 # all .kdl files in a directory (JavaScript)
-ssc-gen generate examples/ -l js -o ./output
+ssc-gen generate js examples/ -o ./output
+
+# Go (goquery + net/http)
+ssc-gen generate go schema.kdl -o ./output
 
 # with custom package name
-ssc-gen generate schema.kdl -l python -L bs4 -o ./parsers --package scraper
+ssc-gen generate python schema.kdl -L bs4 -o ./parsers --package scraper
 
 # with @request support (REST/HTTP codegen)
-ssc-gen generate schema.kdl -l python -L bs4 -o ./out --http-client httpx
+ssc-gen generate python schema.kdl -L bs4 -o ./out --http-client httpx
 
 # extract helper functions into a separate runtime module
-ssc-gen generate schema.kdl -l python -L bs4 -o ./out -R
+ssc-gen generate python schema.kdl -L bs4 -o ./out -R
 ```
 
-Languages (`--lang / -l`): `python`, `js`.
+Languages: `generate python`, `generate js`, `generate go`.
 HTML libraries (`--lib / -L`, Python only): `bs4` (default), `lxml`, `parsel`, `slax`.
 
 ### Lint schemas

{ssc_codegen-0.32.3 → ssc_codegen-0.33.0}/README.md

@@ -37,7 +37,7 @@ uv tool install ssc_codegen
 Generate Python parser:
 
 ```bash
-ssc-gen generate books.kdl -l python -L bs4 -o ./output
+ssc-gen generate python books.kdl -L bs4 -o ./output
 ```
 
 ## Usage
@@ -46,22 +46,25 @@ ssc-gen generate books.kdl -l python -L bs4 -o ./output
 
 ```bash
 # single file (Python + bs4)
-ssc-gen generate schema.kdl -l python -L bs4 -o ./output
+ssc-gen generate python schema.kdl -L bs4 -o ./output
 
 # all .kdl files in a directory (JavaScript)
-ssc-gen generate examples/ -l js -o ./output
+ssc-gen generate js examples/ -o ./output
+
+# Go (goquery + net/http)
+ssc-gen generate go schema.kdl -o ./output
 
 # with custom package name
-ssc-gen generate schema.kdl -l python -L bs4 -o ./parsers --package scraper
+ssc-gen generate python schema.kdl -L bs4 -o ./parsers --package scraper
 
 # with @request support (REST/HTTP codegen)
-ssc-gen generate schema.kdl -l python -L bs4 -o ./out --http-client httpx
+ssc-gen generate python schema.kdl -L bs4 -o ./out --http-client httpx
 
 # extract helper functions into a separate runtime module
-ssc-gen generate schema.kdl -l python -L bs4 -o ./out -R
+ssc-gen generate python schema.kdl -L bs4 -o ./out -R
 ```
 
-Languages (`--lang / -l`): `python`, `js`.
+Languages: `generate python`, `generate js`, `generate go`.
 HTML libraries (`--lib / -L`, Python only): `bs4` (default), `lxml`, `parsel`, `slax`.
 
 ### Lint schemas

{ssc_codegen-0.32.3 → ssc_codegen-0.33.0}/pyproject.toml

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

{ssc_codegen-0.32.3 → ssc_codegen-0.33.0}/ssc_codegen/ast/types.py

@@ -49,3 +49,4 @@ class StructType(IntEnum):
     TABLE = auto()
     FLAT = auto()
     REST = auto()
+    RAW = auto()

{ssc_codegen-0.32.3 → ssc_codegen-0.33.0}/ssc_codegen/core/expressions.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import ast as _py_ast
 import re as _re
 from collections.abc import Sequence
+from types import SimpleNamespace
 from typing import Any, Callable, TypeAlias
 
 from ssc_codegen.ast import (
@@ -206,7 +207,7 @@ def resolve_index_types(
     the element base with is_array=False.
     """
     if parent.body:
-        prev = parent.body[-1]
+        prev = _prev_type_info(parent)
         ret_ti = TypeInfo(base=prev.ret_type_info.base)
         return prev.ret_type_info, ret_ti, prev.is_array
     auto = TypeInfo(base=VariableType.AUTO)
@@ -420,18 +421,26 @@ def parse_expressions(
             raise BuildTimeError(f"Unknown expression: {node.name}")
         lint.push(node.name)
         lint_pipeline_op(node, lint)
-        # Guard: ops in _REQUIRES_PREV access parent.body[-1] unconditionally
-        # in their handlers. Emit a diagnostic and skip the handler when the
-        # pipeline is empty so far, instead of crashing with IndexError.
+        # Guard: ops in _REQUIRES_PREV access parent.body[-1] in their
+        # handlers. Emit a diagnostic and skip when the pipeline is empty —
+        # UNLESS the parent starts with STRING (RAW struct fields), where
+        # string ops are valid as the first operation.
         if not parent.body and node.name in _REQUIRES_PREV:
-            lint.error(
-                node,
-                message=(f"'{node.name}' requires a preceding operation"),
-                code="E100",
-                hint="add a producer first, e.g. `css '.x'; text`",
-            )
-            lint.pop()
-            continue
+            parent_accept = getattr(parent, "accept_type_info", None)
+            if (
+                parent_accept is not None
+                and parent_accept.base == VariableType.STRING
+            ):
+                pass  # RAW struct field — string ops OK as first node
+            else:
+                lint.error(
+                    node,
+                    message=(f"'{node.name}' requires a preceding operation"),
+                    code="E100",
+                    hint="add a producer first, e.g. `css '.x'; text`",
+                )
+                lint.pop()
+                continue
         # Guard: handlers reading node.args[i] without a bounds check would
         # crash with `tuple index out of range` when the user omits args.
         required_args = _MIN_ARGS.get(node.name)
@@ -504,6 +513,28 @@ _ExpressionHandler = Callable[
 _EXPRESSION_HANDLERS: dict[str, _ExpressionHandler] = {}
 
 
+def _prev_type_info(
+    parent: FieldLikeNode,
+) -> SimpleNamespace:
+    """Return a namespace with ``ret_type_info`` and ``is_array`` for the
+    pipeline cursor.
+
+    When the pipeline is non-empty, uses the last node's ret type.
+    When empty (first op), falls back to the parent's accept type —
+    this lets RAW struct fields start directly with string ops
+    (re/split/fmt/etc.) since their document is already a STRING.
+    """
+    if parent.body:
+        prev = parent.body[-1]
+        return SimpleNamespace(
+            ret_type_info=prev.ret_type_info, is_array=prev.is_array
+        )
+    return SimpleNamespace(
+        ret_type_info=parent.accept_type_info,
+        is_array=parent.accept_type_info.is_array,
+    )
+
+
 # Ops whose handlers access ``parent.body[-1]`` unconditionally and therefore
 # require a preceding node. Used by ``parse_expressions`` to emit a clean
 # E100 diagnostic instead of crashing with IndexError on an empty pipeline.
@@ -659,7 +690,7 @@ def _expr_text(
     node: KdlNode, parent: FieldLikeNode, ctx: ParseContext, lint: LintContext
 ):
     if parent.body:
-        prev = parent.body[-1]
+        prev = _prev_type_info(parent)
         accept_ti = prev.ret_type_info
         is_arr = prev.is_array
     else:
@@ -678,7 +709,7 @@ def _expr_raw(
     node: KdlNode, parent: FieldLikeNode, ctx: ParseContext, lint: LintContext
 ):
     if parent.body:
-        prev = parent.body[-1]
+        prev = _prev_type_info(parent)
         accept_ti = prev.ret_type_info
         is_arr = prev.is_array
     else:
@@ -697,7 +728,7 @@ def _expr_attr(
     node: KdlNode, parent: FieldLikeNode, ctx: ParseContext, lint: LintContext
 ):
     if parent.body:
-        prev = parent.body[-1]
+        prev = _prev_type_info(parent)
         accept_ti = prev.ret_type_info
         is_arr = prev.is_array
     else:
@@ -727,7 +758,7 @@ def _expr_trim(
         if node.args
         else ""
     )
-    prev = parent.body[-1]
+    prev = _prev_type_info(parent)
     return Trim(
         parent=parent,
         accept_type_info=prev.ret_type_info,
@@ -749,7 +780,7 @@ def _expr_ltrim(
         if node.args
         else ""
     )
-    prev = parent.body[-1]
+    prev = _prev_type_info(parent)
     return Ltrim(
         parent=parent,
         accept_type_info=prev.ret_type_info,
@@ -771,7 +802,7 @@ def _expr_rtrim(
         if node.args
         else ""
     )
-    prev = parent.body[-1]
+    prev = _prev_type_info(parent)
     return Rtrim(
         parent=parent,
         accept_type_info=prev.ret_type_info,
@@ -785,7 +816,7 @@ def _expr_rtrim(
 def _expr_norm_space(
     node: KdlNode, parent: FieldLikeNode, ctx: ParseContext, lint: LintContext
 ):
-    prev = parent.body[-1]
+    prev = _prev_type_info(parent)
     return NormalizeSpace(
         parent=parent,
         accept_type_info=prev.ret_type_info,
@@ -799,7 +830,7 @@ def _expr_rm_prefix(
     node: KdlNode, parent: FieldLikeNode, ctx: ParseContext, lint: LintContext
 ):
     substr = ctx.property_defines.get(node.args[0].value, node.args[0].value)
-    prev = parent.body[-1]
+    prev = _prev_type_info(parent)
     return RmPrefix(
         parent=parent,
         accept_type_info=prev.ret_type_info,
@@ -814,7 +845,7 @@ def _expr_rm_suffix(
     node: KdlNode, parent: FieldLikeNode, ctx: ParseContext, lint: LintContext
 ):
     substr = ctx.property_defines.get(node.args[0].value, node.args[0].value)
-    prev = parent.body[-1]
+    prev = _prev_type_info(parent)
     return RmSuffix(
         parent=parent,
         accept_type_info=prev.ret_type_info,
@@ -829,7 +860,7 @@ def _expr_rm_prefix_suffix(
     node: KdlNode, parent: FieldLikeNode, ctx: ParseContext, lint: LintContext
 ):
     substr = ctx.property_defines.get(node.args[0].value, node.args[0].value)
-    prev = parent.body[-1]
+    prev = _prev_type_info(parent)
     return RmPrefixSuffix(
         parent=parent,
         accept_type_info=prev.ret_type_info,
@@ -844,7 +875,7 @@ def _expr_fmt(
     node: KdlNode, parent: FieldLikeNode, ctx: ParseContext, lint: LintContext
 ):
     tmpl = ctx.property_defines.get(node.args[0].value, node.args[0].value)
-    prev = parent.body[-1]
+    prev = _prev_type_info(parent)
     return Fmt(
         parent=parent,
         accept_type_info=prev.ret_type_info,
@@ -858,7 +889,7 @@ def _expr_fmt(
 def _expr_repl(
     node: KdlNode, parent: FieldLikeNode, ctx: ParseContext, lint: LintContext
 ):
-    prev = parent.body[-1]
+    prev = _prev_type_info(parent)
     if node.children:
         items = {
             str(child.name): str(child.args[0].value) for child in node.children
@@ -890,7 +921,7 @@ def _expr_repl(
 def _expr_lower(
     node: KdlNode, parent: FieldLikeNode, ctx: ParseContext, lint: LintContext
 ):
-    prev = parent.body[-1]
+    prev = _prev_type_info(parent)
     return Lower(
         parent=parent,
         accept_type_info=prev.ret_type_info,
@@ -903,7 +934,7 @@ def _expr_lower(
 def _expr_upper(
     node: KdlNode, parent: FieldLikeNode, ctx: ParseContext, lint: LintContext
 ):
-    prev = parent.body[-1]
+    prev = _prev_type_info(parent)
     return Upper(
         parent=parent,
         accept_type_info=prev.ret_type_info,
@@ -936,7 +967,7 @@ def _expr_join(
 def _expr_unescape(
     node: KdlNode, parent: FieldLikeNode, ctx: ParseContext, lint: LintContext
 ):
-    prev = parent.body[-1]
+    prev = _prev_type_info(parent)
     return Unescape(
         parent=parent,
         accept_type_info=prev.ret_type_info,
@@ -954,7 +985,7 @@ def _expr_re(
 ):
     raw = ctx.property_defines.get(node.args[0].value, node.args[0].value)
     pattern = normalize_regex_pattern(raw)
-    prev = parent.body[-1]
+    prev = _prev_type_info(parent)
     return Re(
         parent=parent,
         pattern=pattern,
@@ -978,7 +1009,7 @@ def _expr_re_all(
 def _expr_re_sub(
     node: KdlNode, parent: FieldLikeNode, ctx: ParseContext, lint: LintContext
 ):
-    prev = parent.body[-1]
+    prev = _prev_type_info(parent)
     raw = ctx.property_defines.get(node.args[0].value, node.args[0].value)
     pattern = normalize_regex_pattern(raw)
     repl = cast(
@@ -1045,7 +1076,7 @@ def _expr_slice(
 ):
     start, end = int(node.args[0].value), int(node.args[1].value)
     if parent.body:
-        prev = parent.body[-1]
+        prev = _prev_type_info(parent)
         return Slice(
             parent=parent,
             start=start,
@@ -1079,7 +1110,7 @@ def _expr_unique(
 def _expr_to_int(
     node: KdlNode, parent: FieldLikeNode, ctx: ParseContext, lint: LintContext
 ):
-    prev = parent.body[-1]
+    prev = _prev_type_info(parent)
     return ToInt(
         parent=parent,
         accept_type_info=prev.ret_type_info,
@@ -1092,7 +1123,7 @@ def _expr_to_int(
 def _expr_to_float(
     node: KdlNode, parent: FieldLikeNode, ctx: ParseContext, lint: LintContext
 ):
-    prev = parent.body[-1]
+    prev = _prev_type_info(parent)
     return ToFloat(
         parent=parent,
         accept_type_info=prev.ret_type_info,
@@ -1108,7 +1139,7 @@ def _expr_to_bool(
     # Guard against empty parent.body is enforced centrally in
     # parse_expressions via _REQUIRES_PREV — handler is reached only when a
     # preceding node exists.
-    prev = parent.body[-1]
+    prev = _prev_type_info(parent)
     return ToBool(parent=parent, accept_type_info=prev.ret_type_info)
 
 
@@ -1164,7 +1195,7 @@ def _expr_fallback(
     node: KdlNode, parent: FieldLikeNode, ctx: ParseContext, lint: LintContext
 ):
     value = [] if not node.args else node.args[0].value
-    prev = parent.body[-1]
+    prev = _prev_type_info(parent)
     prev_ti = prev.ret_type_info
     fb = Fallback(
         parent=parent,
@@ -1189,7 +1220,7 @@ def _expr_filter(
             ret_type_info=TypeInfo(base=VariableType.DOCUMENT, is_array=True),
             is_array=True,
         )
-    prev = parent.body[-1]
+    prev = _prev_type_info(parent)
     return Filter(
         parent=parent,
         accept_type_info=prev.ret_type_info,

{ssc_codegen-0.32.3 → ssc_codegen-0.33.0}/ssc_codegen/core/linter.py

@@ -49,7 +49,7 @@ def _node_args(node: KdlNode) -> list[str]:
 
 
 _VALID_STRUCT_TYPES = frozenset(
-    {"item", "list", "dict", "table", "flat", "rest"}
+    {"item", "list", "dict", "table", "flat", "rest", "raw"}
 )
 
 _REQUIRED_RESERVED: dict[str, frozenset[str]] = {
@@ -59,15 +59,18 @@ _REQUIRED_RESERVED: dict[str, frozenset[str]] = {
     "table": frozenset({"@table", "@rows", "@match", "@value"}),
     "flat": frozenset(),
     "rest": frozenset({"@request"}),
+    "raw": frozenset(),
 }
 
 _RESERVED_ALLOWED: dict[str, frozenset[str] | None] = {
     "@request": None,
     "@doc": None,
-    "@pre-validate": frozenset({"item", "list", "dict", "table", "flat"}),
-    "@check": frozenset({"item", "list", "dict", "table", "flat"}),
-    "@init": frozenset({"item", "list", "dict", "table", "flat"}),
-    "@split-doc": frozenset({"list", "dict"}),
+    "@pre-validate": frozenset(
+        {"item", "list", "dict", "table", "flat", "raw"}
+    ),
+    "@check": frozenset({"item", "list", "dict", "table", "flat", "raw"}),
+    "@init": frozenset({"item", "list", "dict", "table", "flat", "raw"}),
+    "@split-doc": frozenset({"list", "dict", "raw"}),
     "@key": frozenset({"dict"}),
     "@value": frozenset({"dict", "table"}),
     "@table": frozenset({"table"}),

{ssc_codegen-0.32.3 → ssc_codegen-0.33.0}/ssc_codegen/core/module_handler.py

@@ -42,6 +42,7 @@ def handle_struct(
         "dict": StructType.DICT,
         "table": StructType.TABLE,
         "rest": StructType.REST,
+        "raw": StructType.RAW,
     }
     st = struct_type_map.get(type_)
     if st is None:

{ssc_codegen-0.32.3 → ssc_codegen-0.33.0}/ssc_codegen/core/struct_parser.py

@@ -6,7 +6,11 @@ from collections.abc import Sequence
 from typing import Any
 
 from ssc_codegen.ast import (
+    Attr,
     CheckMethod,
+    CssRemove,
+    CssSelect,
+    CssSelectAll,
     ErrorResponse,
     Field,
     InitField,
@@ -18,6 +22,7 @@ from ssc_codegen.ast import (
     MethodRest,
     Node,
     PreValidate,
+    Raw,
     SplitDoc,
     StartParse,
     StructBase,
@@ -27,9 +32,13 @@ from ssc_codegen.ast import (
     TableConfig,
     TableMatchKey,
     TableRows,
+    Text,
     TypeInfo,
     Value,
     VariableType,
+    XpathRemove,
+    XpathSelect,
+    XpathSelectAll,
 )
 from ssc_codegen.request_spec import parse_to_http
 from kdlquery import KdlNode
@@ -38,6 +47,41 @@ from ssc_codegen.core.contexts import LintContext, ParseContext, WalkCtx
 from ssc_codegen.core.expressions import parse_expressions
 from ssc_codegen.core.type_checking import check_pipeline_types
 
+# AST node types forbidden in (raw)struct — they require a DOM document.
+_RAW_FORBIDDEN_OPS = (
+    CssSelect,
+    CssSelectAll,
+    CssRemove,
+    XpathSelect,
+    XpathSelectAll,
+    XpathRemove,
+    Text,
+    Attr,
+    Raw,
+)
+
+
+def _struct_start_type(struct: StructBase) -> VariableType:
+    """Return the pipeline start type for a struct's fields."""
+    if isinstance(struct, Struct) and struct.type == StructType.RAW:
+        return VariableType.STRING
+    return VariableType.DOCUMENT
+
+
+def _lint_raw_forbidden_ops(expr: Node, lint: LintContext) -> None:
+    """Recursively check that no HTML-only ops appear in a RAW struct node."""
+    for child in expr.body:
+        if isinstance(child, _RAW_FORBIDDEN_OPS):
+            lint.error(
+                child,  # type: ignore[arg-type]
+                message=(
+                    f"HTML operation '{type(child).__name__}' is forbidden in"
+                    " (raw)struct — the document is a plain string, not a DOM"
+                ),
+                code="E001",
+            )
+        _lint_raw_forbidden_ops(child, lint)
+
 
 def parse_struct(
     kdl_nodes: Sequence[KdlNode],
@@ -56,7 +100,11 @@ def parse_struct(
                 _parse_init_fields(node.children, parent, ctx, lint)
         elif node.name == "@pre-validate":
             expr = PreValidate(parent=parent)
+            if isinstance(parent, Struct) and parent.type == StructType.RAW:
+                expr.accept_type_info = TypeInfo(base=VariableType.STRING)
             parse_expressions(node.children, expr, ctx, lint)
+            if isinstance(parent, Struct) and parent.type == StructType.RAW:
+                _lint_raw_forbidden_ops(expr, lint)
             parent.body.append(expr)
         elif node.name == "@check":
             if not node.args:
@@ -68,11 +116,22 @@ def parse_struct(
                 continue
             check_name = str(node.args[0].value)
             expr = CheckMethod(parent=parent, name=check_name)
+            if isinstance(parent, Struct) and parent.type == StructType.RAW:
+                expr.accept_type_info = TypeInfo(base=VariableType.STRING)
             parse_expressions(node.children, expr, ctx, lint)
+            if isinstance(parent, Struct) and parent.type == StructType.RAW:
+                _lint_raw_forbidden_ops(expr, lint)
             parent.body.append(expr)
         elif node.name == "@split-doc":
             expr = SplitDoc(parent=parent)
+            if isinstance(parent, Struct) and parent.type == StructType.RAW:
+                expr.accept_type_info = TypeInfo(base=VariableType.STRING)
+                expr.ret_type_info = TypeInfo(
+                    base=VariableType.STRING, is_array=True
+                )
             parse_expressions(node.children, expr, ctx, lint)
+            if isinstance(parent, Struct) and parent.type == StructType.RAW:
+                _lint_raw_forbidden_ops(expr, lint)
             parent.body.append(expr)
         elif node.name == "@key":
             expr = Key(parent=parent)
@@ -218,12 +277,21 @@ def parse_struct(
             )
             parent.body.append(err)
         else:
+            is_raw = (
+                isinstance(parent, Struct) and parent.type == StructType.RAW
+            )
             if isinstance(parent, Struct) and parent.type == StructType.TABLE:
                 expr = Field(
                     parent=parent,
                     name=node.name,
                     accept_type_info=TypeInfo(base=VariableType.STRING),
                 )
+            elif is_raw:
+                expr = Field(
+                    parent=parent,
+                    name=node.name,
+                    accept_type_info=TypeInfo(base=VariableType.STRING),
+                )
             else:
                 expr = Field(parent=parent, name=node.name)
             ops = list(node.children)
@@ -231,8 +299,13 @@ def parse_struct(
             # Type inference for regular fields
             if ops and not (len(ops) == 1 and ops[0].name == "nested"):
                 check_pipeline_types(
-                    ops, ctx, lint, start_type=VariableType.DOCUMENT
+                    ops,
+                    ctx,
+                    lint,
+                    start_type=_struct_start_type(parent),
                 )
+            if is_raw:
+                _lint_raw_forbidden_ops(expr, lint)
             parent.body.append(expr)
 
     if not isinstance(parent, StructRest):
@@ -321,18 +394,22 @@ def _parse_init_fields(
     prev_ctx = lint.walk_context
     lint.walk_context = WalkCtx.INIT_BLOCK
     init = parent.init
+    is_raw = parent.type == StructType.RAW
+    start_type = _struct_start_type(parent)
     for node in kdl_nodes:
         lint.push(node.name)
         lint.init_fields.add(node.name)
         expr = InitField(parent=parent, name=node.name)
+        if is_raw:
+            expr.accept_type_info = TypeInfo(base=VariableType.STRING)
         parse_expressions(node.children, expr, ctx, lint)
         if expr.body:
             expr.ret_type_info = expr.body[-1].ret_type_info
             ops = list(node.children)
-            ret = check_pipeline_types(
-                ops, ctx, lint, start_type=VariableType.DOCUMENT
-            )
-            lint.inferred_define_types[node.name] = (VariableType.DOCUMENT, ret)
+            ret = check_pipeline_types(ops, ctx, lint, start_type=start_type)
+            lint.inferred_define_types[node.name] = (start_type, ret)
+        if is_raw:
+            _lint_raw_forbidden_ops(expr, lint)
         parent.body.append(expr)
         init.body.append(InitFieldCall(parent=init, name=node.name))
         lint.pop()

{ssc_codegen-0.32.3 → ssc_codegen-0.33.0}/ssc_codegen/health.py

@@ -25,6 +25,8 @@ from ssc_codegen.ast import (
     TableRows,
     TableMatchKey,
     StructBase,
+    Struct,
+    StructType,
     Module,
 )
 from ssc_codegen.ast.base import Node as AstNode
@@ -285,6 +287,20 @@ def check_struct_health(
     soup = BeautifulSoup(html, "lxml")
     result = HealthResult(struct_name=struct.name)
 
+    # RAW structs have no HTML selectors — skip health-check entirely.
+    if isinstance(struct, Struct) and struct.type == StructType.RAW:
+        result.checks.append(
+            SelectorCheck(
+                path=struct.name,
+                selector_type="raw",
+                query="",
+                matches=0,
+                status="warn",
+                message="(raw)struct has no HTML selectors to check",
+            )
+        )
+        return result
+
     # collect selectors + nested refs, then recurse into nested structs
     visited: set[str] = set()
     _check_struct_recursive(

{ssc_codegen-0.32.3 → ssc_codegen-0.33.0}/ssc_codegen/targets/golang/visitor.py

@@ -418,6 +418,9 @@ class GoVisitor(BaseWalker):
                 return f"[]{name}Type"
             case ST.FLAT:
                 return "[]string"
+            case ST.RAW:
+                has_split = any(isinstance(n, SplitDoc) for n in struct.body)
+                return f"[]{name}Type" if has_split else f"{name}Type"
             case _:
                 return "any"
 
@@ -516,7 +519,7 @@ class GoVisitor(BaseWalker):
                 return [f"type {name}Type = map[string]{vt}", ""]
             case ST.TABLE:
                 return [f"type {name}Type = map[string]any", ""]
-            case ST.ITEM | ST.LIST:
+            case ST.ITEM | ST.LIST | ST.RAW:
                 lines = [f"type {name}Type struct {{"]
                 lines.extend(self.walk_children(node, ctx))
                 lines.append("}")
@@ -611,7 +614,9 @@ class GoVisitor(BaseWalker):
                     else f"{ctx.indent}//"
                 )
         lines.append(f"type {name} struct {{")
-        lines.append("\tsel *goquery.Selection")
+        is_raw = isinstance(node, Struct) and node.type == ST.RAW
+        sel_type = "string" if is_raw else "*goquery.Selection"
+        lines.append(f"\tsel {sel_type}")
         init_fields = self._collect_init_fields(node)
         for cn, gt, _ in init_fields:
             lines.append(f"\t{cn} {gt}")
@@ -633,18 +638,28 @@ class GoVisitor(BaseWalker):
     ) -> list[str]:
         i = ctx.indent
         i2 = ctx.deeper().indent
-        lines: list[str] = [
-            f"func New{name}(input string) (*{name}, error) {{",
-            f"{i2}doc, err := goquery.NewDocumentFromReader(strings.NewReader(input))",
-            f"{i2}if err != nil {{",
-            f"{i2}\treturn nil, err",
-            f"{i2}}}",
-            f"{i2}{rcv} := &{name}{{sel: doc.Selection}}",
-        ]
+        is_raw = isinstance(node, Struct) and node.type == ST.RAW
+        if is_raw:
+            lines: list[str] = [
+                f"func New{name}(input string) *{name} {{",
+                f"{i2}{rcv} := &{name}{{sel: input}}",
+            ]
+        else:
+            lines = [
+                f"func New{name}(input string) (*{name}, error) {{",
+                f"{i2}doc, err := goquery.NewDocumentFromReader(strings.NewReader(input))",
+                f"{i2}if err != nil {{",
+                f"{i2}\treturn nil, err",
+                f"{i2}}}",
+                f"{i2}{rcv} := &{name}{{sel: doc.Selection}}",
+            ]
         init_fields = self._collect_init_fields(node)
         if init_fields:
             lines.append(f"{i2}{rcv}.init()")
-        lines.append(f"{i2}return {rcv}, nil")
+        if is_raw:
+            lines.append(f"{i2}return {rcv}")
+        else:
+            lines.append(f"{i2}return {rcv}, nil")
         lines.append(f"{i}}}")
         lines.append("")
         return lines
@@ -935,6 +950,31 @@ class GoVisitor(BaseWalker):
                     lines.append(f"{i2}}}")
                 else:
                     lines.append(f"{i2}return {name}Type{{}}")
+            case ST.RAW:
+                if node.use_split_doc:
+                    lines.append(f"{i2}rows := {rcv}.splitDoc({rcv}.sel)")
+                    lines.append(
+                        f"{i2}result := make([]{name}Type, 0, len(rows))"
+                    )
+                    lines.append(f"{i2}for _, item := range rows {{")
+                    lines.append(f"{i3}result = append(result, {name}Type{{")
+                    for f in node.fields:
+                        fn = _go_field_name(f.name)
+                        mn = _go_method_name(f.name)
+                        lines.append(f"{i4}{fn}: {rcv}.{mn}(item),")
+                    lines.append(f"{i3}}})")
+                    lines.append(f"{i2}}}")
+                    lines.append(f"{i2}return result")
+                else:
+                    if node.fields:
+                        lines.append(f"{i2}return {name}Type{{")
+                        for f in node.fields:
+                            fn = _go_field_name(f.name)
+                            mn = _go_method_name(f.name)
+                            lines.append(f"{i3}{fn}: {rcv}.{mn}({rcv}.sel),")
+                        lines.append(f"{i2}}}")
+                    else:
+                        lines.append(f"{i2}return {name}Type{{}}")
             case ST.LIST:
                 lines.append(f"{i2}rows := {rcv}.splitDoc({rcv}.sel)")
                 lines.append(

{ssc_codegen-0.32.3 → ssc_codegen-0.33.0}/ssc_codegen/targets/javascript/visitor.py

@@ -465,14 +465,22 @@ class JsVisitor(BaseWalker):
         if isinstance(node.parent, StructRest):
             return []
         i1, i2, i3 = ctx.indent, ctx.indent * 2, ctx.indent * 3
-        lines = [
-            f"{i1}constructor(document) {{",
-            f"{i2}if (typeof document === 'string') {{",
-            f"{i3}this._doc = (new DOMParser()).parseFromString(document, 'text/html');",
-            f"{i2}}} else {{",
-            f"{i3}this._doc = document;",
-            f"{i2}}}",
-        ]
+        struct = node.parent
+        is_raw = isinstance(struct, Struct) and struct.type == ST.RAW
+        if is_raw:
+            lines = [
+                f"{i1}constructor(document) {{",
+                f"{i2}this._doc = document;",
+            ]
+        else:
+            lines = [
+                f"{i1}constructor(document) {{",
+                f"{i2}if (typeof document === 'string') {{",
+                f"{i3}this._doc = (new DOMParser()).parseFromString(document, 'text/html');",
+                f"{i2}}} else {{",
+                f"{i3}this._doc = document;",
+                f"{i2}}}",
+            ]
         lines.extend(self.walk_children(node, ctx))
         lines.append(f"{i1}}}")
         return lines
@@ -574,6 +582,9 @@ class JsVisitor(BaseWalker):
             ret_type = f"Array<{name}Type>"
         elif st == ST.FLAT:
             ret_type = "Array<string>"
+        elif st == ST.RAW:
+            has_split = any(isinstance(n, SplitDoc) for n in struct.body)
+            ret_type = f"Array<{name}Type>" if has_split else f"{name}Type"
         else:
             ret_type = f"{name}Type"
         i1, i2, i3 = ctx.indent, ctx.indent * 2, ctx.indent * 3
@@ -642,6 +653,24 @@ class JsVisitor(BaseWalker):
                 )
             lines.append(f"{i2}}}")
             lines.append(f"{i2}return _result;")
+        elif st == ST.RAW:
+            has_split = node.use_split_doc
+            if has_split:
+                lines.append(
+                    f"{i2}return Array.from(this._splitDoc(this._doc)).map(i => ({{"
+                )
+                for f in node.fields:
+                    n = to_camel_case(f.name)
+                    lines.append(f"{i3}{n}: this.{_js_method_name(f.name)}(i),")
+                lines.append(f"{i2}}}));")
+            else:
+                lines.append(f"{i2}return {{")
+                for f in node.fields:
+                    n = to_camel_case(f.name)
+                    lines.append(
+                        f"{i3}{n}: this.{_js_method_name(f.name)}(this._doc),"
+                    )
+                lines.append(f"{i2}}};")
         lines.append(f"{i1}}}")
         return lines
 

{ssc_codegen-0.32.3 → ssc_codegen-0.33.0}/ssc_codegen/targets/python/rest.py

@@ -29,8 +29,8 @@ from ssc_codegen.targets.python.http_libs.base import HttpLibStrategy
 from ssc_codegen.traversal.context import WalkContext
 from ssc_codegen.traversal.utils import (
     dict_needs_builder,
+    module_has_html_struct,
     module_has_rest,
-    module_is_rest_only,
 )
 
 
@@ -245,7 +245,7 @@ def runtime_export_names(
     - Module with REST structs: also import REST names.
     """
     names: list[str] = list(_RUNTIME_ALWAYS_EXPORT_NAMES)
-    if not module_is_rest_only(module):
+    if module_has_html_struct(module):
         names.extend(_RUNTIME_HTML_EXPORT_NAMES)
         if need_fallback:
             names.append("FALLBACK_HTML_STR")

{ssc_codegen-0.32.3 → ssc_codegen-0.33.0}/ssc_codegen/targets/python/visitor.py

@@ -125,8 +125,8 @@ from ssc_codegen.ast import (
 from ssc_codegen.naming import to_pascal_case, to_snake_case
 from ssc_codegen.traversal.utils import (
     jsonify_path_to_segments,
+    module_has_html_struct,
     module_has_rest,
-    module_is_rest_only,
     module_uses_http,
 )
 from ssc_codegen.generation.builder import ModuleBuilder
@@ -340,6 +340,11 @@ class PythonVisitor(BaseWalker):
                 return self.ARRAY_TYPE_FMT.format(f"{name}Type")
             case ST.FLAT:
                 return self.ARRAY_TYPE_FMT.format(self.TYPES[VT.STRING])
+            case ST.RAW:
+                has_split = any(isinstance(n, SplitDoc) for n in struct.body)
+                if has_split:
+                    return self.ARRAY_TYPE_FMT.format(f"{name}Type")
+                return f"{name}Type"
             case _:
                 return self.TYPES[VT.STRING]
 
@@ -350,10 +355,10 @@ class PythonVisitor(BaseWalker):
         if node.doc:
             lines.extend(['"""', node.doc, '"""'])
         has_rest = module_has_rest(node)
-        is_rest_only = module_is_rest_only(node)
         uses_http = module_uses_http(node)
+        has_html = module_has_html_struct(node)
         runtime = ctx.meta.get("runtime_module")
-        if not is_rest_only:
+        if has_html:
             for line in self._dom.parser_imports:
                 self._builder.require_import(line)
         self._builder.require_import(
@@ -419,8 +424,8 @@ class PythonVisitor(BaseWalker):
         lines.extend(self._builder.imports)
         lines.append("")
         mod = node.parent
-        is_rest_only = isinstance(mod, Module) and module_is_rest_only(mod)
-        if not is_rest_only:
+        has_html = isinstance(mod, Module) and module_has_html_struct(mod)
+        if has_html:
             lines.extend(
                 [
                     "class UnmatchedTableRow:",
@@ -481,7 +486,7 @@ class PythonVisitor(BaseWalker):
                 return self.walk_children(node, ctx)
             case ST.FLAT:
                 return [f"{name}Type = List[str]"]
-            case ST.ITEM | ST.LIST | ST.TABLE:
+            case ST.ITEM | ST.LIST | ST.TABLE | ST.RAW:
                 lines = [f'{name}Type = TypedDict("{name}Type", {{']
                 lines.extend(self.walk_children(node, ctx))
                 lines.append("})")
@@ -552,13 +557,21 @@ class PythonVisitor(BaseWalker):
             ctx.deeper().indent,
             ctx.deeper().deeper().indent,
         )
-        lines = [
-            f"{i}def __init__(self, document: {self._dom.init_arg_type}):",
-            f"{i2}if isinstance(document, str):",
-            f"{i3}self._doc = {self._dom.init_from_str_expr}",
-            f"{i2}else:",
-            f"{i3}self._doc = document",
-        ]
+        struct = node.parent
+        is_raw = isinstance(struct, Struct) and struct.type == ST.RAW
+        if is_raw:
+            lines = [
+                f"{i}def __init__(self, document: str):",
+                f"{i2}self._doc = document",
+            ]
+        else:
+            lines = [
+                f"{i}def __init__(self, document: {self._dom.init_arg_type}):",
+                f"{i2}if isinstance(document, str):",
+                f"{i3}self._doc = {self._dom.init_from_str_expr}",
+                f"{i2}else:",
+                f"{i3}self._doc = document",
+            ]
         lines.extend(self.walk_children(node, ctx))
         return lines
 
@@ -713,6 +726,21 @@ class PythonVisitor(BaseWalker):
                     lines.append(f"{i4}_result[{fn!r}] = _{fn}")
                     lines.append(f"{i4}continue")
                 lines.append(f"{i2}return _result")
+            case ST.RAW:
+                if node.use_split_doc:
+                    lines.append(f"{i2}return [{{")
+                    for field in node.fields:
+                        fn = to_snake_case(field.name)
+                        lines.append(f"{i2}{fn!r}: self._parse_{fn}(i),")
+                    lines.append(f"{i3}}} for i in self._split_doc(self._doc)]")
+                else:
+                    lines.append(f"{i2}return {{")
+                    for field in node.fields:
+                        fn = to_snake_case(field.name)
+                        lines.append(
+                            f"{i3}{fn!r}: self._parse_{fn}(self._doc),"
+                        )
+                    lines.append(f"{i3}}}")
         return lines
 
     # === REST / FETCH (delegate to rest.py) ===

{ssc_codegen-0.32.3 → ssc_codegen-0.33.0}/ssc_codegen/traversal/utils.py

@@ -13,8 +13,10 @@ from ssc_codegen.ast import (
     PlaceholderSpec,
     PlaceholderTemplate,
     PreValidate,
+    Struct,
     StructBase,
     StructRest,
+    StructType,
 )
 
 
@@ -46,6 +48,17 @@ def module_is_rest_only(module: Module) -> bool:
     return len(structs) == 0 or all(isinstance(s, StructRest) for s in structs)
 
 
+def module_has_html_struct(module: Module) -> bool:
+    """True if the module has at least one HTML-parsing struct (not REST, not RAW)."""
+    for n in module.body:
+        if isinstance(n, StructRest):
+            continue
+        if isinstance(n, Struct):
+            if n.type != StructType.RAW:
+                return True
+    return False
+
+
 def err_subclass_name(struct_name: str, err: ErrorResponse) -> str:
     """Deterministic error-subclass name from struct name + error spec."""
     from ssc_codegen.core.rest_artifacts import (