ssc_codegen 0.35.0__tar.gz → 0.36.0__tar.gz

{ssc_codegen-0.35.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.35.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.35.0 → ssc_codegen-0.36.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ssc_codegen"
-version = "0.35.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.35.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}, 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",
@@ -293,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.
 
@@ -300,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.
@@ -307,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"
@@ -332,9 +344,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.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.35.0 → ssc_codegen-0.36.0}/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;")