@voxgig/sdkgen 4.32.1 → 4.34.0

package/project/.sdk/src/cmp/py/fragment/Entity.fragment.py

@@ -117,60 +117,68 @@ class EntyClass:
                 return bool(signal())
             return bool(getattr(signal, "aborted", False))
 
-        utility.feature_hook(ctx, "PrePoint")
-        point, err = utility.make_point(ctx)
-        ctx.out["point"] = point
-        if err is not None:
-            return
-
-        utility.feature_hook(ctx, "PreSpec")
-        spec, err = utility.make_spec(ctx)
-        ctx.out["spec"] = spec
-        if err is not None:
-            return
-
-        utility.feature_hook(ctx, "PreRequest")
-        resp, err = utility.make_request(ctx)
-        ctx.out["request"] = resp
-        if err is not None:
-            return
-
-        utility.feature_hook(ctx, "PreResponse")
-        resp2, err = utility.make_response(ctx)
-        ctx.out["response"] = resp2
-        if err is not None:
-            return
-
-        utility.feature_hook(ctx, "PreResult")
-        result, err = utility.make_result(ctx)
-        ctx.out["result"] = result
-        if err is not None:
-            return
-
-        utility.feature_hook(ctx, "PreDone")
-
-        result = ctx.result
-
-        # Inbound: prefer the streaming feature's incremental generator; else
-        # fall back to the materialised items so stream always yields.
-        stream_fn = getattr(result, "stream", None) if result is not None else None
-        if callable(stream_fn):
-            for item in stream_fn():
-                if aborted():
-                    return
-                yield item
-        else:
-            data = utility.done(ctx)
-            if isinstance(data, list):
-                items = data
-            elif data is None:
-                items = []
+        # The pipeline runs as the caller iterates, so its errors leave
+        # through the same catch path as an operation's.
+        try:
+            utility.feature_hook(ctx, "PrePoint")
+            point, err = utility.make_point(ctx)
+            ctx.out["point"] = point
+            if err is not None:
+                return
+
+            utility.feature_hook(ctx, "PreSpec")
+            spec, err = utility.make_spec(ctx)
+            ctx.out["spec"] = spec
+            if err is not None:
+                return
+
+            utility.feature_hook(ctx, "PreRequest")
+            resp, err = utility.make_request(ctx)
+            ctx.out["request"] = resp
+            if err is not None:
+                return
+
+            utility.feature_hook(ctx, "PreResponse")
+            resp2, err = utility.make_response(ctx)
+            ctx.out["response"] = resp2
+            if err is not None:
+                return
+
+            utility.feature_hook(ctx, "PreResult")
+            result, err = utility.make_result(ctx)
+            ctx.out["result"] = result
+            if err is not None:
+                return
+
+            utility.feature_hook(ctx, "PreDone")
+
+            result = ctx.result
+
+            # Inbound: prefer the streaming feature's incremental generator;
+            # else fall back to the materialised items so stream always yields.
+            stream_fn = getattr(result, "stream", None) if result is not None else None
+            if callable(stream_fn):
+                # done() does not run on this path, so its record is cleaned here.
+                utility.clean_explain(ctx)
+                for item in stream_fn():
+                    if aborted():
+                        return
+                    yield item
             else:
-                items = [data]
-            for item in items:
-                if aborted():
-                    return
-                yield item
+                data = utility.done(ctx)
+                if isinstance(data, list):
+                    items = data
+                elif data is None:
+                    items = []
+                else:
+                    items = [data]
+                for item in items:
+                    if aborted():
+                        return
+                    yield item
+        except Exception as err:
+            self._unexpected(ctx, err)
+            raise
 
     # #LoadOp
 
@@ -244,7 +252,27 @@ class EntyClass:
 
             return out
 
-        except Exception:
-            # #PreUnexpected-Hook
+        except Exception as err:
+            # What a hook raises here must not escape the cleaning below.
+            try:
+                # #PreUnexpected-Hook
+            except Exception as hookerr:
+                self._unexpected(ctx, hookerr)
+                raise hookerr from None
 
+            self._unexpected(ctx, err)
             raise
+
+    # An error a hook raised never passed through make_error: it is cleaned,
+    # and so is the explain record it interrupted.
+    def _unexpected(self, ctx, err):
+        clean = self._utility.clean
+        explain = ctx.ctrl.explain
+        if isinstance(explain, dict):
+            self._utility.clean_explain(ctx)
+            cleanerr = clean(ctx, {"message": str(err), "class": type(err).__name__})
+            if not isinstance(explain.get("err"), dict):
+                explain["err"] = cleanerr
+            elif explain["err"].get("message") != cleanerr.get("message"):
+                explain["unexpected"] = cleanerr
+        clean(ctx, err)

package/project/.sdk/src/cmp/py/fragment/Main.fragment.py

@@ -14,11 +14,15 @@ from projectname_sdk.features import _has_feature, _make_feature
 
 
 class ProjectNameSDK:
+    # The options hold the credential. A slot keeps them reachable as
+    # `client.options` and out of `vars(client)` and every attribute dump;
+    # the dict entry keeps the instance open for everything else.
+    __slots__ = ("_options", "__dict__")
 
     def __init__(self, options=None):
         self.mode = "live"
         self.features = []
-        self.options = None
+        self._options = None
 
         utility = ProjectNameUtility()
         self._utility = utility
@@ -87,6 +91,17 @@ class ProjectNameSDK:
 
         # #BuildFeatures
 
+    @property
+    def options(self):
+        return self._options
+
+    @options.setter
+    def options(self, value):
+        self._options = value
+
+    def __repr__(self):
+        return "ProjectNameSDK(mode=" + repr(self.mode) + ")"
+
     def options_map(self):
         out = vs.clone(self.options)
         if isinstance(out, dict):
@@ -209,7 +224,8 @@ class ProjectNameSDK:
         except Exception as err:
             # direct() is the raw-HTTP escape hatch: it never raises, it
             # returns a result object callers branch on via result["ok"].
-            return {"ok": False, "err": err}
+            # That error never passes through make_error, so it is cleaned.
+            return {"ok": False, "err": utility.clean(self._rootctx, err)}
 
         if fetchargs is None:
             fetchargs = {}
@@ -226,7 +242,7 @@ class ProjectNameSDK:
         fetched, fetch_err = utility.fetcher(ctx, url, fetchdef)
 
         if fetch_err is not None:
-            return {"ok": False, "err": fetch_err}
+            return {"ok": False, "err": utility.clean(ctx, fetch_err)}
 
         if fetched is None:
             return {

package/project/.sdk/src/cmp/rb/PrepareAuth_rb.ts

@@ -141,6 +141,9 @@ end
         # \`pack("m0")\` rather than \`Base64.strict_encode64\`: base64 left
         # Ruby's default gems in 3.4, and pack is core.
         b64 = ["#{apikey}:#{no_secret ? "" : secret}"].pack("m0")
+        # The joined, encoded pair is a wire form neither credential's own
+        # registration covers.
+        ctx.utility.clean_add.call(ctx, b64)
         headers[HEADER_AUTH] =
           auth_prefix.empty? ? b64 : "#{auth_prefix} #{b64}"
       end