ssc_codegen 0.35.0__tar.gz → 0.36.1__tar.gz

{ssc_codegen-0.35.0 → ssc_codegen-0.36.1}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: ssc_codegen
-Version: 0.35.0
+Version: 0.36.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.35.0 → ssc_codegen-0.36.1}/pyproject.toml

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

{ssc_codegen-0.35.0 → ssc_codegen-0.36.1}/ssc_codegen/targets/golang/http_libs/nethttp.py

@@ -38,6 +38,13 @@ _NETHTTP_REST_RUNTIME: list[str] = [
     "\t\t\t\t}",
     "\t\t\t}",
     "\t\t}",
+    "\t\tif len(opts.Cookies) > 0 {",
+    "\t\t\tfor name, vs := range opts.Cookies {",
+    "\t\t\t\tfor _, v := range vs {",
+    "\t\t\t\t\treq.AddCookie(&http.Cookie{Name: name, Value: v})",
+    "\t\t\t\t}",
+    "\t\t\t}",
+    "\t\t}",
     '\t\tif opts.Body != "" {',
     "\t\t\treq.Body = io.NopCloser(strings.NewReader(opts.Body))",
     "\t\t}",

{ssc_codegen-0.35.0 → ssc_codegen-0.36.1}/ssc_codegen/targets/golang/rest.py

@@ -90,17 +90,18 @@ def render_body_json(tmpl: PlaceholderTemplate) -> str:
     return f"fmt.Sprintf({_go_str(fmt_str)}, {', '.join(args)})"
 
 
-def render_form_body(body: dict[str, PlaceholderTemplate]) -> str:
-    """Render a form-urlencoded dict body as ``url.Values{...}.Encode()``.
+def render_url_values(d: dict[str, PlaceholderTemplate]) -> str:
+    """Render a ``dict[str, PlaceholderTemplate]`` as ``url.Values{...}.Encode()``.
 
-    Keys are literal strings; values may contain placeholders (rendered via
-    ``fmt.Sprintf`` through ``render_url``). ``url.Values`` properly escapes
-    both keys and values per RFC 3986.
+    Shared by form-body and query-string rendering. Keys are literal
+    strings; values may contain placeholders (rendered via ``fmt.Sprintf``
+    through ``render_url``). ``url.Values`` properly escapes both keys
+    and values per RFC 3986. Empty dict → ``'""'``.
     """
-    if not body:
+    if not d:
         return '""'
     parts: list[str] = []
-    for k, tmpl in body.items():
+    for k, tmpl in d.items():
         val = (
             render_url(tmpl) if tmpl.has_placeholders else _go_str(tmpl.source)
         )
@@ -108,6 +109,43 @@ def render_form_body(body: dict[str, PlaceholderTemplate]) -> str:
     return f"url.Values{{{', '.join(parts)}}}.Encode()"
 
 
+def render_form_body(body: dict[str, PlaceholderTemplate]) -> str:
+    """Form-urlencoded body via ``url.Values.Encode()``."""
+    return render_url_values(body)
+
+
+def render_full_url(spec: RequestHttp) -> str:
+    """URL with query string from ``spec.params`` appended.
+
+    When params is empty, returns ``render_url(spec.url)`` unchanged.
+    Otherwise appends ``+ "?" + <url.Values.Encode()>`` to the base URL.
+    """
+    base = render_url(spec.url)
+    if not spec.params:
+        return base
+    return f'({base} + "?" + {render_url_values(spec.params)})'
+
+
+def _render_cookie_pairs(
+    spec: RequestHttp,
+) -> list[tuple[str, str]]:
+    """Render each cookie as ``(key_expr, value_expr)`` pair.
+
+    Value uses ``fmt.Sprintf`` if it contains placeholders (via ``render_url``),
+    otherwise a plain string literal. Returns ``[]`` when ``spec.cookies`` is
+    empty. Used by both the inline HTML-@request path (``req.AddCookie``) and
+    the REST path (``sscReqOpts.Cookies``).
+    """
+    pairs: list[tuple[str, str]] = []
+    for k, tmpl in spec.cookies.items():
+        key = _go_str(k)
+        value = (
+            render_url(tmpl) if tmpl.has_placeholders else _go_str(tmpl.source)
+        )
+        pairs.append((key, value))
+    return pairs
+
+
 # ===========================================================================
 # Placeholder parameter signature
 # ===========================================================================
@@ -154,9 +192,10 @@ def _build_opts(spec: RequestHttp, indent: str) -> list[str]:
     """Build sscReqOpts construction lines."""
     lines: list[str] = []
     has_headers = bool(spec.headers)
+    has_cookies = bool(spec.cookies)
     has_body = spec.body_kind not in ("empty", None) and spec.body is not None
 
-    if not has_headers and not has_body:
+    if not has_headers and not has_body and not has_cookies:
         return [f"{indent}nil"]
 
     lines.append(f"{indent}&sscReqOpts{{")
@@ -176,6 +215,9 @@ def _build_opts(spec: RequestHttp, indent: str) -> list[str]:
                 val = _go_str(tmpl.source)
             parts.append(f"{_go_str(k)}: []string{{{val}}}")
         lines.append(f"{indent}\tHeaders: sscHeaders{{{', '.join(parts)}}},")
+    if has_cookies:
+        parts = [f"{k}: []string{{{v}}}" for k, v in _render_cookie_pairs(spec)]
+        lines.append(f"{indent}\tCookies: sscHeaders{{{', '.join(parts)}}},")
     lines.append(f"{indent}}}")
     return lines
 
@@ -185,9 +227,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,15 +245,16 @@ 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)
+    url_expr = render_full_url(spec)
 
     i1 = ctx.indent
     i2 = i1 + ctx.indent_char
 
     lines: list[str] = [
-        f"{i1}func {method_name}(ctx context.Context, client {http.client_type}{ph_params}, opts ...sscReqOpt) (*{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",
@@ -220,6 +268,13 @@ def emit_method_fetch(
         )
         lines.append(f"{i2}req.Header.Set({_go_str(k)}, {val})")
 
+    # Cookies inline (per-cookie AddCookie — values may interpolate
+    # placeholders via fmt.Sprintf produced by _render_cookie_pairs).
+    for key, val in _render_cookie_pairs(spec):
+        lines.append(
+            f"{i2}req.AddCookie(&http.Cookie{{Name: {key}, Value: {val}}})"
+        )
+
     # Body inline (json/raw or form).
     if spec.body_kind in ("json", "raw") and spec.body is not None:
         if isinstance(spec.body, PlaceholderTemplate):
@@ -293,6 +348,7 @@ def emit_method_rest(
     node: MethodRest,
     ctx: WalkContext,
     http: GoHttpLibStrategy,
+    rcv: str,
 ) -> list[str]:
     """Emit a Go REST method that calls sscRestCall.
 
@@ -300,6 +356,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.
@@ -307,10 +367,11 @@ 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"
-    url_expr = render_url(spec.url)
+    url_expr = render_full_url(spec)
 
     # Resolve return type from AST response_schema (no `any`).
     if node.response_schema:
@@ -332,9 +393,9 @@ 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}, opts ...sscReqOpt) ({ret_type}, error) {{"
+        f"{i1}func ({rcv} {name}) {method_name}(client {http.client_type}{ph_params}, opts ...sscReqOpt) ({ret_type}, error) {{"
     )
 
     # Build _opts from DSL, apply per-call user opts, then call sscRestCall.

{ssc_codegen-0.35.0 → ssc_codegen-0.36.1}/ssc_codegen/targets/golang/runtime.py

@@ -490,6 +490,7 @@ BASE_REST_RUNTIME: list[str] = [
     "",
     "type sscReqOpts struct {",
     "\tHeaders sscHeaders",
+    "\tCookies sscHeaders",
     "\tBody    string",
     "}",
     "",

{ssc_codegen-0.35.0 → ssc_codegen-0.36.1}/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
@@ -1884,8 +1890,17 @@ class GoVisitor(BaseWalker):
         spec = node.http_request
         if spec.body_kind == "form" and isinstance(spec.body, dict):
             self._builder.require_import('"net/url"')
+        if spec.params:
+            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
@@ -1899,6 +1914,8 @@ class GoVisitor(BaseWalker):
         spec = node.http_request
         if spec.body_kind == "form" and isinstance(spec.body, dict):
             self._builder.require_import('"net/url"')
+        if spec.params:
+            self._builder.require_import('"net/url"')
         if node.response_path:
             self._builder.require_import('"github.com/tidwall/gjson"')
         return rest.emit_method_fetch(node, ctx, self._http)

{ssc_codegen-0.35.0 → ssc_codegen-0.36.1}/ssc_codegen/targets/javascript/rest.py

@@ -390,14 +390,20 @@ 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} * @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}, opts = {{}}) {{")
+    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}    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;")
@@ -443,7 +449,9 @@ 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}, opts = {{}}) {{"]
+    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).
@@ -471,7 +479,9 @@ def emit_method_fetch(
         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}    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;")
@@ -495,15 +505,15 @@ def emit_method_fetch(
         if headers_expr:
             kw_parts.append(f"headers: {headers_expr}")
         if spec.cookies:
-            kw_parts.append(
-                f"// cookies: {render_obj(spec.cookies)},"
-            )
+            kw_parts.append(f"// cookies: {render_obj(spec.cookies)},")
         if body_expr:
             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}    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;")