ssc_codegen 0.32.0__tar.gz → 0.32.1__tar.gz

{ssc_codegen-0.32.0 → ssc_codegen-0.32.1}/PKG-INFO

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

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

{ssc_codegen-0.32.0 → ssc_codegen-0.32.1}/ssc_codegen/ast/struct.py

@@ -337,6 +337,19 @@ class MethodBase(Node):
 
     name: str = ""  # method name suffix; "" = default fetch()
 
+    #: Dot-notation JSON path extracted from the 2xx response body before it
+    #: becomes ``Ok.value`` (REST) or the parser input (fetch). Example:
+    #: ``"data.user"`` resolves ``{"data": {"user": ...}}`` to the inner
+    #: object. When set together with ``response_schema`` (REST), the path
+    #: wins: the schema type-checks the *extracted* sub-object, not the
+    #: whole envelope. ``@error`` matchers always run against the full body.
+    response_path: str = ""
+
+    #: Join separator applied when ``response_path`` resolves to a
+    #: ``list[str]`` (fetch-only). Forbidden on ``MethodRest``; the linter
+    #: rejects ``response-join`` on ``type=rest`` structs.
+    response_join: str = ""
+
     @property
     def http_request(self) -> RequestHttp:
         return [n for n in self.body if isinstance(n, RequestHttp)][0]
@@ -353,11 +366,6 @@ class MethodFetch(MethodBase):
     ``fetch()`` returns a parser instance constructed from the HTTP response body.
     """
 
-    response_path: str = ""  # dot-notation JSON path, e.g. "payload.html"
-    response_join: str = (
-        ""  # join separator when response-path resolves to list[str]
-    )
-
 
 @dataclass
 class MethodRest(MethodBase):

{ssc_codegen-0.32.0 → ssc_codegen-0.32.1}/ssc_codegen/core/struct_parser.py

@@ -107,8 +107,54 @@ def parse_struct(
             )
             http = parse_to_http(raw_payload)
             method_name = node.get_prop("name") or ""
-            if isinstance(parent, StructRest):
+            response_path_val = node.get_prop("response-path") or ""
+            response_join_val = node.get_prop("response-join") or ""
+
+            is_rest = isinstance(parent, StructRest)
+
+            # Lint: response-path format (dot-notation, non-empty segments).
+            if response_path_val:
+                segments = response_path_val.split(".")
+                bad = any(not seg for seg in segments) or any(
+                    not seg.replace("-", "_").isidentifier() for seg in segments
+                )
+                if bad:
+                    lint.error(
+                        node,
+                        message=(
+                            "response-path must be dot-notation with "
+                            "non-empty ASCII identifier segments "
+                            '(e.g. "data.user"); got '
+                            f"{response_path_val!r}"
+                        ),
+                        code="E001",
+                    )
+
+            # Lint: response-join only on fetch-track.
+            if response_join_val and is_rest:
+                lint.error(
+                    node,
+                    message=(
+                        "response-join is forbidden on type=rest structs "
+                        "(use response-path alone; Ok.value is the "
+                        "extracted object)"
+                    ),
+                    code="E001",
+                )
+
+            # Lint: response-join without response-path is meaningless.
+            if response_join_val and not response_path_val:
+                lint.error(
+                    node,
+                    message=(
+                        "response-join requires response-path (nothing to join)"
+                    ),
+                    code="E001",
+                )
+
+            if is_rest:
                 rest_method = MethodRest(parent=parent, name=method_name)
+                rest_method.response_path = response_path_val
                 response_schema_val = node.get_prop("response") or ""
                 rest_method.response_schema = str(
                     ctx.property_defines.get(
@@ -124,12 +170,8 @@ def parse_struct(
                 parent.body.append(rest_method)
             else:
                 fetch_method = MethodFetch(parent=parent, name=method_name)
-                fetch_method.response_path = (
-                    node.get_prop("response-path") or ""
-                )
-                fetch_method.response_join = (
-                    node.get_prop("response-join") or ""
-                )
+                fetch_method.response_path = response_path_val
+                fetch_method.response_join = response_join_val
                 http.parent = fetch_method
                 fetch_method.body.append(http)
                 parent.body.append(fetch_method)

{ssc_codegen-0.32.0 → ssc_codegen-0.32.1}/ssc_codegen/targets/golang/rest.py

@@ -333,15 +333,15 @@ def emit_method_rest(
 
     # Call sscRestCall — inline if nil, multi-line if struct literal.
     # For void responses, use `_` since the body is discarded.
-    body_var = "_" if not node.response_schema else "_body"
+    body_var = "_" if not node.response_schema else "body"
     if len(opts_lines) == 1:
         lines.append(
-            f"{i2}{body_var}, _err := sscRestCall(client, {matchers_var}, "
+            f"{i2}{body_var}, err := sscRestCall(client, {matchers_var}, "
             f"{_go_str(spec.method)}, {url_expr}, {opts_lines[0].strip()})"
         )
     else:
         lines.append(
-            f"{i2}{body_var}, _err := sscRestCall(client, {matchers_var}, "
+            f"{i2}{body_var}, err := sscRestCall(client, {matchers_var}, "
             f"{_go_str(spec.method)}, {url_expr},"
         )
         lines.append(f"{opts_lines[0].strip()}")
@@ -350,28 +350,35 @@ def emit_method_rest(
         lines.append(f"{opts_lines[-1].strip()})")
 
     # Error propagation.
-    lines.append(f"{i2}if _err != nil {{")
-    lines.append(f"{i2}\treturn {zero}, _err")
+    lines.append(f"{i2}if err != nil {{")
+    lines.append(f"{i2}\treturn {zero}, err")
     lines.append(f"{i2}}}")
 
     # Parse response body (when typed) or return void.
     if node.response_schema:
         schema_go = f"{to_pascal_case(node.response_schema)}Json"
+        # response_path extraction: narrow body to the sub-object before
+        # Unmarshal. gjson `.Raw` preserves JSON structure (works for both
+        # scalar-object and array paths). Path wins over schema: the
+        # schema type-checks the *extracted* value, not the envelope.
+        if node.response_path:
+            path = _go_str(node.response_path)
+            lines.append(f"{i2}body = []byte(gjson.GetBytes(body, {path}).Raw)")
         if getattr(node, "response_is_array", False):
-            lines.append(f"{i2}var _val []{schema_go}")
+            lines.append(f"{i2}var val []{schema_go}")
         else:
-            lines.append(f"{i2}var _val {schema_go}")
+            lines.append(f"{i2}var val {schema_go}")
         lines.append(
-            f"{i2}if _perr := json.Unmarshal(_body, &_val); _perr != nil {{"
+            f"{i2}if perr := json.Unmarshal(body, &val); perr != nil {{"
         )
         lines.append(
-            f'{i2}\treturn {zero}, fmt.Errorf("ssc-gen: parse {schema_go}: %w", _perr)'
+            f'{i2}\treturn {zero}, fmt.Errorf("ssc-gen: parse {schema_go}: %w", perr)'
         )
         lines.append(f"{i2}}}")
         if getattr(node, "response_is_array", False):
-            lines.append(f"{i2}return _val, nil")
+            lines.append(f"{i2}return val, nil")
         else:
-            lines.append(f"{i2}return &_val, nil")
+            lines.append(f"{i2}return &val, nil")
     else:
         lines.append(f"{i2}return {zero}, nil")
 

{ssc_codegen-0.32.0 → ssc_codegen-0.32.1}/ssc_codegen/targets/golang/visitor.py

@@ -1812,6 +1812,8 @@ class GoVisitor(BaseWalker):
         self._builder.require_import('"fmt"')
         if node.response_schema:
             self._builder.require_import('"encoding/json"')
+        if node.response_path:
+            self._builder.require_import('"github.com/tidwall/gjson"')
         spec = node.http_request
         if spec.body_kind == "form" and isinstance(spec.body, dict):
             self._builder.require_import('"net/url"')

{ssc_codegen-0.32.0 → ssc_codegen-0.32.1}/ssc_codegen/targets/javascript/rest.py

@@ -7,6 +7,8 @@ Called by JsVisitor via thin delegate methods.  The HTTP library strategy
 
 from __future__ import annotations
 
+import json
+
 from ssc_codegen.ast import (
     JsonDef,
     MatcherListDef,
@@ -334,7 +336,15 @@ def emit_method_rest(
     )
 
     fn_name = http.fn_name
-    value_fn = "(_b) => null" if not node.response_schema else "null"
+    if node.response_path:
+        accessor = "".join(
+            f"[{json.dumps(p)}]" for p in node.response_path.split(".")
+        )
+        value_fn = f"(_b) => _b{accessor}"
+    elif not node.response_schema:
+        value_fn = "(_b) => null"
+    else:
+        value_fn = "null"
 
     if http_client == "axios":
         url_expr = render_value(spec.url)

{ssc_codegen-0.32.0 → ssc_codegen-0.32.1}/ssc_codegen/targets/python/rest.py

@@ -420,9 +420,12 @@ def emit_method_rest(
         spec, i2, i3, include_method_url=False
     )
 
-    void_kwarg: list[str] = []
-    if not node.response_schema:
-        void_kwarg = [f"{i3}value_fn=lambda _: None,"]
+    value_kwarg: list[str] = []
+    if node.response_path:
+        accessor = "".join(f"[{p!r}]" for p in node.response_path.split("."))
+        value_kwarg = [f"{i3}value_fn=lambda _b: _b{accessor},"]
+    elif not node.response_schema:
+        value_kwarg = [f"{i3}value_fn=lambda _: None,"]
 
     def _body(fn_name: str, await_kw: str) -> list[str]:
         body: list[str] = []
@@ -442,7 +445,7 @@ def emit_method_rest(
             f"{i3}client, {matchers_var}, {spec.method!r},"
             f" {render_value(spec.url)},"
         )
-        body.extend(void_kwarg)
+        body.extend(value_kwarg)
         body.extend(kwargs_lines)
         body.append(f"{i2}))")
         return body