ssc_codegen 0.34.0__tar.gz → 0.36.0__tar.gz

{ssc_codegen-0.34.0 → ssc_codegen-0.36.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: ssc_codegen
-Version: 0.34.0
+Version: 0.36.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

{ssc_codegen-0.34.0 → ssc_codegen-0.36.0}/pyproject.toml

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

{ssc_codegen-0.34.0 → ssc_codegen-0.36.0}/ssc_codegen/targets/golang/rest.py

@@ -185,9 +185,14 @@ def emit_method_fetch(
     ctx: WalkContext,
     http: GoHttpLibStrategy,
 ) -> list[str]:
-    """Emit a Go Fetch method for HTML-parser structs with ``@request``.
+    """Emit a Go HTTP-entry function for HTML-parser structs with ``@request``.
 
-    Signature: ``func Fetch(ctx context.Context, client *http.Client, <phs>) (*Name, error)``
+    Signature: ``func New<Struct><Method>(ctx, client, <phs>, opts ...) (*Name, error)``
+
+    Free function (not a receiver method) — semantically a sibling of
+    ``New<Name>(input string)`` that fetches the input from HTTP instead.
+    Struct-name prefix guarantees uniqueness across schemas in the same
+    package (default ``New<Name>Fetch``; ``@request name=X`` → ``New<Name>X``).
 
     Idiomatic Go: cancellation via ``context.Context``, async via ``go f(ctx)``
     on caller side. Headers/body inlined (no ``sscReqOpts`` dependency).
@@ -198,7 +203,8 @@ def emit_method_fetch(
     struct = node.parent
     assert isinstance(struct, StructBase)
     name = to_pascal_case(struct.name)
-    method_name = to_pascal_case(node.name) if node.name else "Fetch"
+    method_suffix = to_pascal_case(node.name) if node.name else "Fetch"
+    func_name = f"New{name}{method_suffix}"
     ph_params = placeholder_params(spec)
     url_expr = render_url(spec.url)
 
@@ -206,7 +212,7 @@ def emit_method_fetch(
     i2 = i1 + ctx.indent_char
 
     lines: list[str] = [
-        f"{i1}func {method_name}(ctx context.Context, client {http.client_type}{ph_params}) (*{name}, error) {{",
+        f"{i1}func {func_name}(ctx context.Context, client {http.client_type}{ph_params}, opts ...sscReqOpt) (*{name}, error) {{",
         f"{i2}req, err := http.NewRequestWithContext(ctx, {_go_str(spec.method)}, {url_expr}, nil)",
         f"{i2}if err != nil {{",
         f"{i2}\treturn nil, err",
@@ -233,6 +239,15 @@ def emit_method_fetch(
             f"{i2}req.Body = io.NopCloser(strings.NewReader({body_expr}))"
         )
 
+    # Apply per-call opts (user headers are additive).
+    lines.append(f"{i2}if len(opts) > 0 {{")
+    lines.append(f"{i2}\t_opts := &sscReqOpts{{}}")
+    lines.append(f"{i2}\tfor _, o := range opts {{ o(_opts) }}")
+    lines.append(f"{i2}\tfor _k, _vs := range _opts.Headers {{")
+    lines.append(f"{i2}\t\tfor _, _v := range _vs {{ req.Header.Add(_k, _v) }}")
+    lines.append(f"{i2}\t}}")
+    lines.append(f"{i2}}}")
+
     # Execute.
     lines.extend(
         [
@@ -284,6 +299,7 @@ def emit_method_rest(
     node: MethodRest,
     ctx: WalkContext,
     http: GoHttpLibStrategy,
+    rcv: str,
 ) -> list[str]:
     """Emit a Go REST method that calls sscRestCall.
 
@@ -291,6 +307,10 @@ def emit_method_rest(
       - typed value  → ``(*SchemaJson, error)`` or ``([]SchemaJson, error)``
       - void         → ``(struct{}, error)``
 
+    Receiver method on the (empty) marker struct — namespaced by type so
+    multiple REST structs in one package don't collide. Caller writes
+    ``NewApiX().Fetch(client, opts...)`` (factory + receiver).
+
     Errors propagate as typed structs: ``@error`` variants via matchers,
     ``*UnknownErr`` for unmatched HTTP >= 400, ``*TransportErr`` for network.
     Caller uses ``errors.As`` to discriminate.
@@ -298,6 +318,7 @@ def emit_method_rest(
     spec = node.http_request.with_renamed_placeholders(to_camel_case)
     struct = node.parent
     assert isinstance(struct, StructBase)
+    name = to_pascal_case(struct.name)
     method_name = to_pascal_case(node.name) if node.name else "Fetch"
     ph_params = placeholder_params(spec)
     matchers_var = f"{to_snake_case(struct.name)}Matchers"
@@ -323,31 +344,30 @@ def emit_method_rest(
 
     lines: list[str] = []
 
-    # Function signature.
+    # Function signature (receiver method on marker struct).
     lines.append(
-        f"{i1}func {method_name}(client {http.client_type}{ph_params}) ({ret_type}, error) {{"
+        f"{i1}func ({rcv} {name}) {method_name}(client {http.client_type}{ph_params}, opts ...sscReqOpt) ({ret_type}, error) {{"
     )
 
-    # Build opts.
-    opts_lines = _build_opts(spec, i2)
-
-    # Call sscRestCall — inline if nil, multi-line if struct literal.
-    # For void responses, use `_` since the body is discarded.
+    # Build _opts from DSL, apply per-call user opts, then call sscRestCall.
+    opts_lines = _build_opts(spec, i2 + "\t")
     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"{_go_str(spec.method)}, {url_expr}, {opts_lines[0].strip()})"
-        )
+
+    # Assign DSL opts to _opts variable.
+    if len(opts_lines) == 1 and opts_lines[0].strip() == "nil":
+        lines.append(f"{i2}_opts := &sscReqOpts{{}}")
     else:
-        lines.append(
-            f"{i2}{body_var}, err := sscRestCall(client, {matchers_var}, "
-            f"{_go_str(spec.method)}, {url_expr},"
-        )
-        lines.append(f"{opts_lines[0].strip()}")
-        for ol in opts_lines[1:-1]:
+        lines.append(f"{i2}_opts := {opts_lines[0].strip()}")
+        for ol in opts_lines[1:]:
             lines.append(ol)
-        lines.append(f"{opts_lines[-1].strip()})")
+
+    # Apply per-call opts (functional options).
+    lines.append(f"{i2}for _, o := range opts {{ o(_opts) }}")
+
+    lines.append(
+        f"{i2}{body_var}, err := sscRestCall(client, {matchers_var}, "
+        f"{_go_str(spec.method)}, {url_expr}, _opts)"
+    )
 
     # Error propagation.
     lines.append(f"{i2}if err != nil {{")

{ssc_codegen-0.34.0 → ssc_codegen-0.36.0}/ssc_codegen/targets/golang/runtime.py

@@ -493,6 +493,20 @@ BASE_REST_RUNTIME: list[str] = [
     "\tBody    string",
     "}",
     "",
+    "// sscReqOpt is a functional option for per-call request overrides.",
+    "// Applied after DSL-specified opts; user headers are additive (shallow-merge).",
+    "type sscReqOpt func(*sscReqOpts)",
+    "",
+    "// WithHeader adds a per-call header value (additive — does not replace DSL headers).",
+    "func WithHeader(key, val string) sscReqOpt {",
+    "\treturn func(o *sscReqOpts) {",
+    "\t\tif o.Headers == nil {",
+    "\t\t\to.Headers = sscHeaders{}",
+    "\t\t}",
+    "\t\to.Headers[key] = append(o.Headers[key], val)",
+    "\t}",
+    "}",
+    "",
     "type sscErrMatcher struct {",
     "\tStatus  int",
     "\tCheck   func([]byte) bool",

{ssc_codegen-0.34.0 → ssc_codegen-0.36.0}/ssc_codegen/targets/golang/visitor.py

@@ -596,6 +596,12 @@ class GoVisitor(BaseWalker):
         lines.append(f"type {name} struct {{")
         lines.append("}")
         lines.append("")
+        # Empty-struct factory: caller writes New<Name>().Method(...) —
+        # the struct is a pure namespace marker (no state), receiver
+        # methods namespaced by type avoid collisions across schemas in
+        # the same package.
+        lines.append(f"func New{name}() {name} {{ return {name}{{}} }}")
+        lines.append("")
         for child in node.body:
             lines.extend(self.walk(child, ctx))
         return lines
@@ -1885,7 +1891,14 @@ class GoVisitor(BaseWalker):
         if spec.body_kind == "form" and isinstance(spec.body, dict):
             self._builder.require_import('"net/url"')
         self._builder.require_import('"' + self._http.import_path + '"')
-        return rest.emit_method_rest(node, ctx, self._http)
+        struct = node.parent
+        name = (
+            to_pascal_case(struct.name)
+            if isinstance(struct, StructBase)
+            else "X"
+        )
+        rcv = _receiver(name)
+        return rest.emit_method_rest(node, ctx, self._http, rcv)
 
     def visit_method_fetch(
         self, node: MethodFetch, ctx: WalkContext

{ssc_codegen-0.34.0 → ssc_codegen-0.36.0}/ssc_codegen/targets/javascript/rest.py

@@ -390,13 +390,28 @@ def emit_method_rest(
             t = f"{t}[]"
         bracket = f"[params.{p.name}]" if p.is_optional else f"params.{p.name}"
         lines.append(f"{i1} * @param {{{t}}} {bracket}")
+    lines.append(
+        f"{i1} * @param {{Object}} [opts] per-call request options (headers, etc.)"
+    )
     lines.append(f"{i1} * @returns {{Promise<{return_union}>}}")
     lines.append(f"{i1} */")
-    lines.append(f"{i1}static async {method_name}(client{ph_param}) {{")
+    lines.append(
+        f"{i1}static async {method_name}(client{ph_param}, opts = {{}}) {{"
+    )
     lines.extend(pre_lines)
+    lines.append(f"{i2}const _kw = {opts_obj};")
+    lines.append(f"{i2}for (const [_k, _v] of Object.entries(opts)) {{")
+    lines.append(
+        f"{i2}    if (typeof _kw[_k] === 'object' && _kw[_k] !== null && typeof _v === 'object' && _v !== null) {{"
+    )
+    lines.append(f"{i2}        _kw[_k] = {{..._kw[_k], ..._v}};")
+    lines.append(f"{i2}    }} else {{")
+    lines.append(f"{i2}        _kw[_k] = _v;")
+    lines.append(f"{i2}    }}")
+    lines.append(f"{i2}}}")
     lines.append(
         f"{i2}return {fn_name}(client, {matchers_var}, "
-        f"{spec.method!r}, {url_expr}, {value_fn}, {opts_obj});"
+        f"{spec.method!r}, {url_expr}, {value_fn}, _kw);"
     )
     lines.append(f"{i1}}}")
     return lines
@@ -434,9 +449,13 @@ def emit_method_fetch(
         rl.append(f"{i2}return new {struct_name}(_body);")
         return rl
 
-    lines: list[str] = [f"{i1}static async {method_name}(client{ph_param}) {{"]
+    lines: list[str] = [
+        f"{i1}static async {method_name}(client{ph_param}, opts = {{}}) {{"
+    ]
     lines.extend(pre_lines)
 
+    # Build _kw from DSL-specified request options (method/url stay out).
+    kw_parts: list[str] = []
     if http_client == "fetch":
         if params_expr:
             url_inner = spec.url.map(
@@ -446,21 +465,32 @@ def emit_method_fetch(
             url_expr = f"`{url_inner}?${{new URLSearchParams({params_expr})}}`"
         else:
             url_expr = render_value(spec.url)
-        options: list[str] = [f"{i3}method: {spec.method!r},"]
         if headers_expr:
-            options.append(f"{i3}headers: {headers_expr},")
+            kw_parts.append(f"headers: {headers_expr}")
         if spec.cookies:
             cookie_str = "; ".join(
                 f"{k}={v.source}" for k, v in spec.cookies.items()
             )
-            options.append(
-                f"{i3}// cookies: {cookie_str!r}  /* set via headers or credentials */"
+            kw_parts.append(
+                f"// cookies: {cookie_str!r}  /* set via headers or credentials */"
             )
         if body_expr:
-            options.append(f"{i3}body: {body_expr},")
-        lines.append(f"{i2}const _resp = await client({url_expr}, {{")
-        lines.extend(options)
-        lines.append(f"{i2}}});")
+            kw_parts.append(f"body: {body_expr}")
+        kw_obj = "{" + ", ".join(kw_parts) + "}" if kw_parts else "{}"
+        lines.append(f"{i2}const _kw = {kw_obj};")
+        lines.append(f"{i2}for (const [_k, _v] of Object.entries(opts)) {{")
+        lines.append(
+            f"{i2}    if (typeof _kw[_k] === 'object' && _kw[_k] !== null && typeof _v === 'object' && _v !== null) {{"
+        )
+        lines.append(f"{i2}        _kw[_k] = {{..._kw[_k], ..._v}};")
+        lines.append(f"{i2}    }} else {{")
+        lines.append(f"{i2}        _kw[_k] = _v;")
+        lines.append(f"{i2}    }}")
+        lines.append(f"{i2}}}")
+        lines.append(
+            f"{i2}const _resp = await client({url_expr},"
+            f" {{ method: {spec.method!r}, ..._kw }});"
+        )
         lines.append(
             f"{i2}if (!_resp.ok) throw new Error(`HTTP ${{_resp.status}}`);"
         )
@@ -469,23 +499,30 @@ def emit_method_fetch(
         else:
             lines.extend(_response_lines("await _resp.text()"))
     else:
-        req_props: list[str] = [
-            f"{i3}method: {spec.method!r},",
-            f"{i3}url: {render_value(spec.url)},",
-        ]
+        url_expr = render_value(spec.url)
         if params_expr:
-            req_props.append(f"{i3}params: {params_expr},")
+            kw_parts.append(f"params: {params_expr}")
         if headers_expr:
-            req_props.append(f"{i3}headers: {headers_expr},")
+            kw_parts.append(f"headers: {headers_expr}")
         if spec.cookies:
-            req_props.append(
-                f"{i3}// cookies: {render_obj(spec.cookies)},",
-            )
+            kw_parts.append(f"// cookies: {render_obj(spec.cookies)},")
         if body_expr:
-            req_props.append(f"{i3}data: {body_expr},")
-        lines.append(f"{i2}const _resp = await client.request({{")
-        lines.extend(req_props)
-        lines.append(f"{i2}}});")
+            kw_parts.append(f"data: {body_expr}")
+        kw_obj = "{" + ", ".join(kw_parts) + "}" if kw_parts else "{}"
+        lines.append(f"{i2}const _kw = {kw_obj};")
+        lines.append(f"{i2}for (const [_k, _v] of Object.entries(opts)) {{")
+        lines.append(
+            f"{i2}    if (typeof _kw[_k] === 'object' && _kw[_k] !== null && typeof _v === 'object' && _v !== null) {{"
+        )
+        lines.append(f"{i2}        _kw[_k] = {{..._kw[_k], ..._v}};")
+        lines.append(f"{i2}    }} else {{")
+        lines.append(f"{i2}        _kw[_k] = _v;")
+        lines.append(f"{i2}    }}")
+        lines.append(f"{i2}}}")
+        lines.append(
+            f"{i2}const _resp = await client.request({{"
+            f" method: {spec.method!r}, url: {url_expr}, ..._kw }});"
+        )
         lines.extend(_response_lines("_resp.data"))
 
     lines.append(f"{i1}}}")

{ssc_codegen-0.34.0 → ssc_codegen-0.36.0}/ssc_codegen/targets/python/rest.py

@@ -296,32 +296,44 @@ def placeholder_args(http: RequestHttp) -> str:
 # ===========================================================================
 
 
-def _build_kwargs(
-    spec: RequestHttp, i2: str, i3: str, include_method_url: bool
+def _build_kw_dict(
+    spec: RequestHttp, i2: str, i3: str
 ) -> tuple[list[str], list[str]]:
-    """Build (pre_lines, kwargs_lines) for request call.
+    """Build (pre_lines, kw_assign_lines) for ``_kw`` dict construction.
 
-    include_method_url=True for fetch (client.request(method, url, ...)).
-    include_method_url=False for rest (ssc_rest_call(client, matchers, method, url, ...)).
+    Produces ``_kw["headers"] = {...}`` style assignments so caller kwargs
+    can be shallow-merged into the same dict before passing ``**_kw`` to
+    ``client.request()`` / ``ssc_rest_call()``.
+
+    pre_lines:   builder helper code (complex dicts needing intermediate vars).
+    kw_lines:    ``_kw["key"] = value`` assignment lines (at i2 indent).
     """
     pre_lines: list[str] = []
-    kwargs_lines: list[str] = []
-    if include_method_url:
-        kwargs_lines.append(f"{i3}{spec.method!r},")
-        kwargs_lines.append(f"{i3}{render_value(spec.url)},")
+    kw_lines: list[str] = []
     for attr, varname in _DICT_KWARGS:
         d = getattr(spec, attr)
         if not d:
             continue
         if dict_needs_builder(d):
             pre_lines.extend(emit_dict_builder(varname, d, i2))
-            kwargs_lines.append(f"{i3}{attr}={varname},")
+            kw_lines.append(f'{i2}_kw["{attr}"] = {varname}')
         else:
-            kwargs_lines.append(f"{i3}{attr}={render_dict(d)},")
+            kw_lines.append(f'{i2}_kw["{attr}"] = {render_dict(d)}')
     body_result = render_body(spec)
     if body_result:
-        kwargs_lines.append(f"{i3}{body_result[0]}={body_result[1]},")
-    return pre_lines, kwargs_lines
+        kw_lines.append(f'{i2}_kw["{body_result[0]}"] = {body_result[1]}')
+    return pre_lines, kw_lines
+
+
+def _merge_loop_lines(i2: str) -> list[str]:
+    """Shallow-merge user kwargs into _kw (dict keys merged key-by-key)."""
+    return [
+        f"{i2}for _k, _v in kwargs.items():",
+        f"{i2}    if isinstance(_kw.get(_k), dict) and isinstance(_v, dict):",
+        f"{i2}        _kw[_k] = {{**_kw[_k], **_v}}",
+        f"{i2}    else:",
+        f"{i2}        _kw[_k] = _v",
+    ]
 
 
 # ===========================================================================
@@ -343,9 +355,22 @@ def emit_method_fetch(
     i2 = i1 + ctx.indent_char
     i3 = i2 + ctx.indent_char
 
-    pre_lines, kwargs_lines = _build_kwargs(
-        spec, i2, i3, include_method_url=True
-    )
+    pre_lines, kw_lines = _build_kw_dict(spec, i2, i3)
+
+    # kwargs_lines for fetch_body_lines: method, url, **_kw
+    fetch_kwargs = [
+        f"{i3}{spec.method!r},",
+        f"{i3}{render_value(spec.url)},",
+        f"{i3}**_kw,",
+    ]
+
+    def _kw_setup() -> list[str]:
+        """Lines to build _kw dict + merge user kwargs before the request."""
+        setup: list[str] = [f"{i2}_kw: Dict[str, Any] = {{}}"]
+        setup.extend(pre_lines)
+        setup.extend(kw_lines)
+        setup.extend(_merge_loop_lines(i2))
+        return setup
 
     lines: list[str] = []
 
@@ -353,14 +378,14 @@ def emit_method_fetch(
     if http.supports_sync_fetch:
         lines.append(f"{i1}@classmethod")
         lines.append(
-            f'{i1}def fetch{suffix}(cls, client: {http.sync_client_type}{ph_params}) -> "{struct_name}":'
+            f'{i1}def fetch{suffix}(cls, client: {http.sync_client_type}{ph_params}, **kwargs: Any) -> "{struct_name}":'
         )
-        lines.extend(pre_lines)
+        lines.extend(_kw_setup())
         lines.extend(
             http.fetch_body_lines(
                 is_async=False,
                 request_call=f"{i2}_resp = client.request(",
-                kwargs_lines=kwargs_lines,
+                kwargs_lines=fetch_kwargs,
                 response_path=node.response_path,
                 response_join=node.response_join,
                 i2=i2,
@@ -372,24 +397,27 @@ def emit_method_fetch(
     # --- async_fetch ------------------------------------------------------
     lines.append(f"{i1}@classmethod")
     lines.append(
-        f'{i1}async def async_fetch{suffix}(cls, client: {http.async_client_type}{ph_params}) -> "{struct_name}":'
+        f'{i1}async def async_fetch{suffix}(cls, client: {http.async_client_type}{ph_params}, **kwargs: Any) -> "{struct_name}":'
     )
     if http.async_fetch_delegates_to_sync:
         # requests: no native async — run the sync fetch in a worker thread
         # via asyncio.to_thread (non-blocking, yields control to the loop).
-        to_thread_args = f"client, {ph_kwargs}" if ph_kwargs else "client"
+        if ph_kwargs:
+            to_thread_args = f"client, {ph_kwargs}, **kwargs"
+        else:
+            to_thread_args = "client, **kwargs"
         lines.append(f"{i2}import asyncio")
         lines.append(
             f"{i2}return await asyncio.to_thread("
             f"cls.fetch{suffix}, {to_thread_args})"
         )
     else:
-        lines.extend(pre_lines)
+        lines.extend(_kw_setup())
         lines.extend(
             http.fetch_body_lines(
                 is_async=True,
                 request_call=f"{i2}_resp = await client.request(",
-                kwargs_lines=kwargs_lines,
+                kwargs_lines=fetch_kwargs,
                 response_path=node.response_path,
                 response_join=node.response_join,
                 i2=i2,
@@ -416,9 +444,7 @@ def emit_method_rest(
 
     doc_line = f'{i2}"""{node.doc}"""' if node.doc else None
 
-    pre_lines, kwargs_lines = _build_kwargs(
-        spec, i2, i3, include_method_url=False
-    )
+    pre_lines, kw_lines = _build_kw_dict(spec, i2, i3)
 
     value_kwarg: list[str] = []
     if node.response_path:
@@ -431,36 +457,31 @@ def emit_method_rest(
         body: list[str] = []
         if doc_line:
             body.append(doc_line)
+        body.append(f"{i2}_kw: Dict[str, Any] = {{}}")
         body.extend(pre_lines)
-        # Wrap in cast(): ssc_rest_call returns Union[Ok[_T], Err] (Err
-        # base — it cannot know the specific Err subclasses that the
-        # heterogeneous matchers list will produce at runtime). The
-        # parser-declared Result alias narrows to the precise union
-        # (Err400 | UnknownErr | TransportErr | ...). cast() documents
-        # this intent at the call site without suppressing mypy via
-        # ``# type: ignore``; the wrapping method's return type is the
-        # stable monad consumers see.
+        body.extend(kw_lines)
+        body.extend(_merge_loop_lines(i2))
         body.append(f"{i2}return cast({ret_type}, {await_kw}{fn_name}(")
         body.append(
             f"{i3}client, {matchers_var}, {spec.method!r},"
             f" {render_value(spec.url)},"
         )
         body.extend(value_kwarg)
-        body.extend(kwargs_lines)
+        body.append(f"{i3}**_kw,")
         body.append(f"{i2}))")
         return body
 
     lines: list[str] = []
     lines.append(f"{i1}@classmethod")
     lines.append(
-        f"{i1}def {method_name}(cls, client: {http.sync_client_type}{ph_params}) -> {ret_type}:"
+        f"{i1}def {method_name}(cls, client: {http.sync_client_type}{ph_params}, **kwargs: Any) -> {ret_type}:"
     )
     lines.extend(_body("ssc_rest_call", ""))
     lines.append("")
 
     lines.append(f"{i1}@classmethod")
     lines.append(
-        f"{i1}async def async_{method_name}(cls, client: {http.async_client_type}{ph_params}) -> {ret_type}:"
+        f"{i1}async def async_{method_name}(cls, client: {http.async_client_type}{ph_params}, **kwargs: Any) -> {ret_type}:"
     )
     lines.extend(_body("ssc_rest_call_async", "await "))
     return lines