fix(metadata): degrade gracefully on hostile default reprs

py-default->jvm stringified opaque Python defaults with str(py-str x),
which (1) was unbounded for huge reprs, (2) only handled a top-level
opaque so a collection default (e.g. a tuple of classes) leaked raw
pointers, and (3) threw when a default's repr raised, dropping the var
from the namespace.

safe-py-str truncates long reprs and falls back to "<unprintable>" when
repr/str raises; py-default->jvm now falls back to a str() of the whole
default whenever any nested value is opaque.

Recursive- and hanging-repr cases are left out: the former is a native
crash in libpython-clj's stringify path, the latter needs a timeout.

Author: jsavyasachi

src/libpython_clj2/metadata.clj

@@ -69,12 +69,23 @@
     (catch Exception _
       nil)))
 
+(def ^:private default-repr-max-len 200)
+
+(defn- safe-py-str [x]
+  (let [s (try (str (py-str x))
+               (catch Throwable _ "<unprintable>"))]
+    (if (> (count s) default-repr-max-len)
+      (str (subs s 0 default-repr-max-len) "...")
+      s)))
+
+(defn- opaque? [v]
+  (and (map? v) (contains? v :type) (contains? v :value)))
+
 (defn- py-default->jvm [x]
   (let [jvm-val (->jvm x)]
-    (if (and (map? jvm-val)
-             (contains? jvm-val :type)
-             (contains? jvm-val :value))
-      (str (py-str x))
+    ;; nested opaques have no JVM form and leak pointers - stringify instead
+    (if (some opaque? (tree-seq coll? seq jvm-val))
+      (safe-py-str x)
       jvm-val)))
 
 (defn- py-defaults->jvm [defaults]

test/libpython_clj2/metadata_test.clj

@@ -1,5 +1,6 @@
 (ns libpython-clj2.metadata-test
   (:require [clojure.test :refer :all]
+            [clojure.string :as str]
             [libpython-clj2.python :as py]
             [libpython-clj2.metadata :as metadata]))
 
@@ -43,3 +44,49 @@
            (-> kw-default-type-fn
                metadata/py-fn-argspec
                metadata/pyarglists)))))
+
+(defn- tc [n] (py/get-attr (py/import-module "testcode") n))
+
+(defn- default-of [n sym]
+  (->> (-> (tc n) metadata/py-fn-argspec metadata/pyarglists first)
+       (tree-seq coll? seq) (filter map?) first sym))
+
+(deftest py-default-class-object
+  (is (= "<class 'int'>" (default-of "f_class" 'x))))
+
+(deftest py-default-bad-repr-preserves-var
+  (is (= '([& [{x "<unprintable>"}]] [])
+         (-> (tc "f_badstr") metadata/py-fn-argspec metadata/pyarglists))))
+
+(deftest py-default-custom-repr
+  (is (= (apply str (repeat 40 "x")) (default-of "f_weird" 'x))))
+
+(deftest py-default-partial
+  (is (= "functools.partial(<class 'int'>, 0)" (default-of "f_partial" 'x))))
+
+(deftest py-default-nested-opaque-no-pointer-leak
+  (is (= "(<class 'int'>, <class 'str'>)" (default-of "f_nested_opaque" 'x))))
+
+(deftest py-default-lambda
+  (is (str/starts-with? (default-of "f_lambda" 'x) "<function <lambda> at 0x")))
+
+(deftest py-default-sentinel
+  (is (str/starts-with? (default-of "f_sentinel" 'x) "<object object at 0x")))
+
+(deftest py-default-huge-truncated
+  (let [s (default-of "f_huge" 'model)]
+    (is (<= (count s) 203))
+    (is (str/ends-with? s "..."))))
+
+(deftest py-default-huge-kwonly-truncated
+  (let [s (default-of "f_kw_huge" 'model)]
+    (is (<= (count s) 203))
+    (is (str/ends-with? s "..."))))
+
+(deftest py-default-mixed
+  (let [m (->> (-> (tc "f_mixed") metadata/py-fn-argspec metadata/pyarglists first)
+               (tree-seq coll? seq) (filter map?) first)]
+    (is (= 1 (m 'b)))
+    (is (= "<class 'int'>" (m 'c)))
+    (is (str/starts-with? (m 'd) "<object object at 0x"))
+    (is (= 2 (m 'e)))))

testcode/__init__.py

@@ -1,3 +1,6 @@
+import functools
+
+
 class WithObjClass:
     def __init__(self, suppress, fn_list):
         self.suppress = suppress
@@ -70,3 +73,68 @@ def kw_default_type_fn(*, dtype=int):
         1, 2, 10, 11, 12, d=10, e=10
     ),
 }
+
+
+class BadStr:
+    def __repr__(self):
+        raise ValueError("boom repr")
+    def __str__(self):
+        raise ValueError("boom str")
+
+
+class WeirdStr:
+    def __repr__(self):
+        return "x" * 40
+
+
+class HugeReprModel:
+    def __init__(self, n_layers=300):
+        self.n_layers = n_layers
+
+    def __repr__(self):
+        lines = ["GnarlyNet("]
+        for i in range(self.n_layers):
+            lines.append(f"  (layer{i}): Linear(in_features=4096, out_features=4096, bias=True)")
+            lines.append(f"  (act{i}): GELU(approximate='none')")
+            lines.append(f"  (drop{i}): Dropout(p=0.1, inplace=False)")
+        lines.append(")")
+        return "\n".join(lines)
+    __str__ = __repr__
+
+
+_bad = BadStr()
+_weird = WeirdStr()
+_sentinel = object()
+_partial = functools.partial(int, 0)
+_huge = HugeReprModel(300)
+
+
+def f_class(x=int):
+    return x
+
+def f_lambda(x=lambda a: a):
+    return x
+
+def f_badstr(x=_bad):
+    return x
+
+def f_weird(x=_weird):
+    return x
+
+def f_sentinel(x=_sentinel):
+    return x
+
+def f_partial(x=_partial):
+    return x
+
+def f_nested_opaque(x=(int, str)):
+    return x
+
+def f_huge(model=_huge):
+    return model
+
+def f_kw_huge(*, model=_huge):
+    return model
+
+def f_mixed(a, b=1, c=int, *, d=_sentinel, e=2):
+    return (a, b, c, d, e)