@tracecode/harness 0.4.0

package/dist/python.cjs

@@ -0,0 +1,744 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// packages/harness-python/src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  PYTHON_CLASS_DEFINITIONS: () => PYTHON_CLASS_DEFINITIONS,
+  PYTHON_CONVERSION_HELPERS: () => PYTHON_CONVERSION_HELPERS,
+  PYTHON_EXECUTE_SERIALIZE_FUNCTION: () => PYTHON_EXECUTE_SERIALIZE_FUNCTION,
+  PYTHON_INTERVIEW_MATERIALIZE_SERIALIZE_FUNCTION: () => PYTHON_INTERVIEW_MATERIALIZE_SERIALIZE_FUNCTION,
+  PYTHON_PRACTICE_MATERIALIZE_SERIALIZE_FUNCTION: () => PYTHON_PRACTICE_MATERIALIZE_SERIALIZE_FUNCTION,
+  PYTHON_SERIALIZE_FUNCTION: () => PYTHON_SERIALIZE_FUNCTION,
+  PYTHON_TRACE_SERIALIZE_FUNCTION: () => PYTHON_TRACE_SERIALIZE_FUNCTION,
+  TEMPLATE_PYTHON_CLASS_DEFINITIONS: () => TEMPLATE_PYTHON_CLASS_DEFINITIONS,
+  TEMPLATE_PYTHON_CONVERSION_HELPERS: () => TEMPLATE_PYTHON_CONVERSION_HELPERS,
+  TEMPLATE_PYTHON_EXECUTE_SERIALIZE_FUNCTION: () => TEMPLATE_PYTHON_EXECUTE_SERIALIZE_FUNCTION,
+  TEMPLATE_PYTHON_INTERVIEW_MATERIALIZE_SERIALIZE_FUNCTION: () => TEMPLATE_PYTHON_INTERVIEW_MATERIALIZE_SERIALIZE_FUNCTION,
+  TEMPLATE_PYTHON_PRACTICE_MATERIALIZE_SERIALIZE_FUNCTION: () => TEMPLATE_PYTHON_PRACTICE_MATERIALIZE_SERIALIZE_FUNCTION,
+  TEMPLATE_PYTHON_SERIALIZE_FUNCTION: () => TEMPLATE_PYTHON_SERIALIZE_FUNCTION,
+  TEMPLATE_PYTHON_TRACE_SERIALIZE_FUNCTION: () => TEMPLATE_PYTHON_TRACE_SERIALIZE_FUNCTION,
+  generateConversionCode: () => generateConversionCode,
+  generateInputSetup: () => generateInputSetup,
+  generateSolutionScript: () => generateSolutionScript,
+  identifyConversions: () => identifyConversions,
+  templateToPythonLiteral: () => templateToPythonLiteral,
+  toPythonLiteral: () => toPythonLiteral
+});
+module.exports = __toCommonJS(src_exports);
+
+// packages/harness-python/src/generated/python-harness-snippets.ts
+function toPythonLiteral(value) {
+  if (value === null || value === void 0) {
+    return "None";
+  }
+  if (typeof value === "boolean") {
+    return value ? "True" : "False";
+  }
+  if (typeof value === "number") {
+    return String(value);
+  }
+  if (typeof value === "string") {
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) {
+    return "[" + value.map(toPythonLiteral).join(", ") + "]";
+  }
+  if (typeof value === "object") {
+    const entries = Object.entries(value).map(([k, v]) => `${JSON.stringify(k)}: ${toPythonLiteral(v)}`).join(", ");
+    return "{" + entries + "}";
+  }
+  return JSON.stringify(value);
+}
+var PYTHON_CLASS_DEFINITIONS = `
+class TreeNode:
+    def __init__(self, val=0, left=None, right=None):
+        self.val = val
+        self.value = val
+        self.left = left
+        self.right = right
+    def __getitem__(self, key):
+        if key == 'val': return getattr(self, 'val', getattr(self, 'value', None))
+        if key == 'value': return getattr(self, 'value', getattr(self, 'val', None))
+        if key == 'left': return self.left
+        if key == 'right': return self.right
+        raise KeyError(key)
+    def get(self, key, default=None):
+        if key == 'val': return getattr(self, 'val', getattr(self, 'value', default))
+        if key == 'value': return getattr(self, 'value', getattr(self, 'val', default))
+        if key == 'left': return self.left
+        if key == 'right': return self.right
+        return default
+    def __repr__(self):
+        return f"TreeNode({getattr(self, 'val', getattr(self, 'value', None))})"
+
+class ListNode:
+    def __init__(self, val=0, next=None):
+        self.val = val
+        self.value = val
+        self.next = next
+    def __getitem__(self, key):
+        if key == 'val': return getattr(self, 'val', getattr(self, 'value', None))
+        if key == 'value': return getattr(self, 'value', getattr(self, 'val', None))
+        if key == 'next': return self.next
+        raise KeyError(key)
+    def get(self, key, default=None):
+        if key == 'val': return getattr(self, 'val', getattr(self, 'value', default))
+        if key == 'value': return getattr(self, 'value', getattr(self, 'val', default))
+        if key == 'next': return self.next
+        return default
+    def __repr__(self):
+        return f"ListNode({getattr(self, 'val', getattr(self, 'value', None))})"
+`;
+var PYTHON_CONVERSION_HELPERS = "\ndef _ensure_node_value_aliases(node):\n    if node is None:\n        return node\n    try:\n        has_val = hasattr(node, 'val')\n        has_value = hasattr(node, 'value')\n        if has_value and not has_val:\n            try:\n                setattr(node, 'val', getattr(node, 'value'))\n            except Exception:\n                pass\n        elif has_val and not has_value:\n            try:\n                setattr(node, 'value', getattr(node, 'val'))\n            except Exception:\n                pass\n    except Exception:\n        pass\n    return node\n\ndef _dict_to_tree(d):\n    if d is None:\n        return None\n    if not isinstance(d, dict):\n        return d\n    if 'val' not in d and 'value' not in d:\n        return d\n    node = TreeNode(d.get('val', d.get('value', 0)))\n    _ensure_node_value_aliases(node)\n    node.left = _dict_to_tree(d.get('left'))\n    node.right = _dict_to_tree(d.get('right'))\n    return node\n\ndef _dict_to_list(d, _refs=None):\n    if _refs is None:\n        _refs = {}\n    if d is None:\n        return None\n    if not isinstance(d, dict):\n        return d\n    if '__ref__' in d:\n        return _refs.get(d.get('__ref__'))\n    if 'val' not in d and 'value' not in d:\n        return d\n    node = ListNode(d.get('val', d.get('value', 0)))\n    _ensure_node_value_aliases(node)\n    node_id = d.get('__id__')\n    if isinstance(node_id, str) and node_id:\n        _refs[node_id] = node\n    node.next = _dict_to_list(d.get('next'), _refs)\n    return node\n";
+var PYTHON_TRACE_SERIALIZE_FUNCTION = `
+# Sentinel to mark skipped values (functions, etc.) - distinct from None
+_SKIP_SENTINEL = "__TRACECODE_SKIP__"
+_MAX_SERIALIZE_DEPTH = 48
+
+def _serialize(obj, depth=0, node_refs=None):
+    if node_refs is None:
+        node_refs = {}
+    if isinstance(obj, (bool, int, str, type(None))):
+        return obj
+    elif isinstance(obj, float):
+        if not math.isfinite(obj):
+            if math.isnan(obj):
+                return "NaN"
+            return "Infinity" if obj > 0 else "-Infinity"
+        return obj
+    if depth > _MAX_SERIALIZE_DEPTH:
+        return "<max depth>"
+    elif isinstance(obj, (list, tuple)):
+        return [_serialize(x, depth + 1, node_refs) for x in obj]
+    elif getattr(obj, '__class__', None) and getattr(obj.__class__, '__name__', '') == 'deque':
+        return [_serialize(x, depth + 1, node_refs) for x in obj]
+    elif isinstance(obj, dict):
+        return {str(k): _serialize(v, depth + 1, node_refs) for k, v in obj.items()}
+    elif isinstance(obj, set):
+        # Use try/except for sorting to handle heterogeneous sets
+        try:
+            sorted_vals = sorted([_serialize(x, depth + 1, node_refs) for x in obj])
+        except TypeError:
+            sorted_vals = [_serialize(x, depth + 1, node_refs) for x in obj]
+        return {"__type__": "set", "values": sorted_vals}
+    elif (hasattr(obj, 'val') or hasattr(obj, 'value')) and (hasattr(obj, 'left') or hasattr(obj, 'right')):
+        obj_ref = id(obj)
+        if obj_ref in node_refs:
+            return {"__ref__": node_refs[obj_ref]}
+        node_id = f"tree-{obj_ref}"
+        node_refs[obj_ref] = node_id
+        result = {
+            "__type__": "TreeNode",
+            "__id__": node_id,
+            "val": _serialize(getattr(obj, 'val', getattr(obj, 'value', None)), depth + 1, node_refs),
+        }
+        if hasattr(obj, 'left'):
+            result["left"] = _serialize(obj.left, depth + 1, node_refs)
+        if hasattr(obj, 'right'):
+            result["right"] = _serialize(obj.right, depth + 1, node_refs)
+        return result
+    elif (hasattr(obj, 'val') or hasattr(obj, 'value')) and hasattr(obj, 'next'):
+        obj_ref = id(obj)
+        if obj_ref in node_refs:
+            return {"__ref__": node_refs[obj_ref]}
+        node_id = f"list-{obj_ref}"
+        node_refs[obj_ref] = node_id
+        result = {
+            "__type__": "ListNode",
+            "__id__": node_id,
+            "val": _serialize(getattr(obj, 'val', getattr(obj, 'value', None)), depth + 1, node_refs),
+        }
+        result["next"] = _serialize(obj.next, depth + 1, node_refs)
+        return result
+    elif callable(obj):
+        # Skip functions entirely - return sentinel
+        return _SKIP_SENTINEL
+    else:
+        repr_str = repr(obj)
+        # Filter out function-like representations (e.g., <function foo at 0x...>)
+        if repr_str.startswith('<') and repr_str.endswith('>'):
+            return _SKIP_SENTINEL
+        return repr_str
+`;
+var PYTHON_EXECUTE_SERIALIZE_FUNCTION = `
+_MAX_SERIALIZE_DEPTH = 48
+
+def _serialize(obj, depth=0):
+    if isinstance(obj, (bool, int, str, type(None))):
+        return obj
+    elif isinstance(obj, float):
+        if not math.isfinite(obj):
+            if math.isnan(obj):
+                return "NaN"
+            return "Infinity" if obj > 0 else "-Infinity"
+        return obj
+    if depth > _MAX_SERIALIZE_DEPTH:
+        return "<max depth>"
+    elif isinstance(obj, (list, tuple)):
+        return [_serialize(x, depth + 1) for x in obj]
+    elif getattr(obj, '__class__', None) and getattr(obj.__class__, '__name__', '') == 'deque':
+        return [_serialize(x, depth + 1) for x in obj]
+    elif isinstance(obj, dict):
+        return {str(k): _serialize(v, depth + 1) for k, v in obj.items()}
+    elif isinstance(obj, set):
+        try:
+            return {"__type__": "set", "values": sorted([_serialize(x, depth + 1) for x in obj])}
+        except TypeError:
+            return {"__type__": "set", "values": [_serialize(x, depth + 1) for x in obj]}
+    elif (hasattr(obj, 'val') or hasattr(obj, 'value')) and (hasattr(obj, 'left') or hasattr(obj, 'right')):
+        result = {"__type__": "TreeNode", "val": _serialize(getattr(obj, 'val', getattr(obj, 'value', None)), depth + 1)}
+        if hasattr(obj, 'left'):
+            result["left"] = _serialize(obj.left, depth + 1)
+        if hasattr(obj, 'right'):
+            result["right"] = _serialize(obj.right, depth + 1)
+        return result
+    elif (hasattr(obj, 'val') or hasattr(obj, 'value')) and hasattr(obj, 'next'):
+        result = {"__type__": "ListNode", "val": _serialize(getattr(obj, 'val', getattr(obj, 'value', None)), depth + 1)}
+        result["next"] = _serialize(obj.next, depth + 1)
+        return result
+    elif callable(obj):
+        return None
+    else:
+        repr_str = repr(obj)
+        if repr_str.startswith('<') and repr_str.endswith('>'):
+            return None
+        return repr_str
+`;
+var PYTHON_PRACTICE_MATERIALIZE_SERIALIZE_FUNCTION = `
+def _serialize(obj, depth=0, state=None):
+    if state is None:
+        state = {"nodes": 0, "seen": set()}
+    if depth > 64:
+        return "__MAX_DEPTH__"
+    if isinstance(obj, (int, float, str, bool, type(None))):
+        return obj
+
+    state["nodes"] += 1
+    if state["nodes"] > 600:
+        return "__MAX_NODES__"
+
+    if isinstance(obj, (list, tuple)):
+        return [_serialize(x, depth + 1, state) for x in obj]
+    elif isinstance(obj, dict):
+        return {str(k): _serialize(v, depth + 1, state) for k, v in obj.items()}
+    elif isinstance(obj, set):
+        serialized = [_serialize(x, depth + 1, state) for x in obj]
+        try:
+            serialized = sorted(serialized)
+        except TypeError:
+            pass
+        return {"__type__": "set", "values": serialized}
+    elif (hasattr(obj, 'val') or hasattr(obj, 'value')) and (hasattr(obj, 'left') or hasattr(obj, 'right')):
+        obj_id = id(obj)
+        if obj_id in state["seen"]:
+            return "__CYCLE__"
+        state["seen"].add(obj_id)
+        result = {"__type__": "TreeNode", "val": _serialize(getattr(obj, 'val', getattr(obj, 'value', None)), depth + 1, state)}
+        if hasattr(obj, 'left'):
+            result["left"] = _serialize(obj.left, depth + 1, state)
+        if hasattr(obj, 'right'):
+            result["right"] = _serialize(obj.right, depth + 1, state)
+        state["seen"].remove(obj_id)
+        return result
+    elif (hasattr(obj, 'val') or hasattr(obj, 'value')) and hasattr(obj, 'next'):
+        obj_id = id(obj)
+        if obj_id in state["seen"]:
+            return "__CYCLE__"
+        state["seen"].add(obj_id)
+        result = {"__type__": "ListNode", "val": _serialize(getattr(obj, 'val', getattr(obj, 'value', None)), depth + 1, state)}
+        result["next"] = _serialize(obj.next, depth + 1, state)
+        state["seen"].remove(obj_id)
+        return result
+    else:
+        return repr(obj)
+`;
+var PYTHON_INTERVIEW_MATERIALIZE_SERIALIZE_FUNCTION = `
+def _serialize(obj, depth=0):
+    if depth > 10:
+        return "<max depth>"
+    if isinstance(obj, (int, float, str, bool, type(None))):
+        return obj
+    elif isinstance(obj, (list, tuple)):
+        return [_serialize(x, depth + 1) for x in obj]
+    elif isinstance(obj, dict):
+        return {str(k): _serialize(v, depth + 1) for k, v in obj.items()}
+    elif isinstance(obj, set):
+        try:
+            return {"__type__": "set", "values": sorted([_serialize(x, depth + 1) for x in obj])}
+        except TypeError:
+            return {"__type__": "set", "values": [_serialize(x, depth + 1) for x in obj]}
+    elif hasattr(obj, 'val') and (hasattr(obj, 'left') or hasattr(obj, 'right')):
+        result = {"__type__": "TreeNode", "val": _serialize(getattr(obj, 'val', None), depth + 1)}
+        if hasattr(obj, 'left'):
+            result["left"] = _serialize(obj.left, depth + 1)
+        if hasattr(obj, 'right'):
+            result["right"] = _serialize(obj.right, depth + 1)
+        return result
+    elif hasattr(obj, 'val') and hasattr(obj, 'next'):
+        result = {"__type__": "ListNode", "val": _serialize(getattr(obj, 'val', None), depth + 1)}
+        result["next"] = _serialize(obj.next, depth + 1)
+        return result
+    else:
+        return repr(obj)
+`;
+var PYTHON_SERIALIZE_FUNCTION = `
+_MAX_SERIALIZE_DEPTH = 48
+
+def _serialize(obj, depth=0):
+    if isinstance(obj, (bool, int, str, type(None))):
+        return obj
+    elif isinstance(obj, float):
+        if not math.isfinite(obj):
+            if math.isnan(obj):
+                return "NaN"
+            return "Infinity" if obj > 0 else "-Infinity"
+        return obj
+    if depth > _MAX_SERIALIZE_DEPTH:
+        return "<max depth>"
+    elif isinstance(obj, (list, tuple)):
+        return [_serialize(x, depth + 1) for x in obj]
+    elif getattr(obj, '__class__', None) and getattr(obj.__class__, '__name__', '') == 'deque':
+        return [_serialize(x, depth + 1) for x in obj]
+    elif isinstance(obj, dict):
+        return {str(k): _serialize(v, depth + 1) for k, v in obj.items()}
+    elif isinstance(obj, set):
+        try:
+            return {"__type__": "set", "values": sorted([_serialize(x, depth + 1) for x in obj])}
+        except TypeError:
+            return {"__type__": "set", "values": [_serialize(x, depth + 1) for x in obj]}
+    elif (hasattr(obj, 'val') or hasattr(obj, 'value')) and (hasattr(obj, 'left') or hasattr(obj, 'right')):
+        result = {"__type__": "TreeNode", "val": _serialize(getattr(obj, 'val', getattr(obj, 'value', None)), depth + 1)}
+        if hasattr(obj, 'left'):
+            result["left"] = _serialize(obj.left, depth + 1)
+        if hasattr(obj, 'right'):
+            result["right"] = _serialize(obj.right, depth + 1)
+        return result
+    elif (hasattr(obj, 'val') or hasattr(obj, 'value')) and hasattr(obj, 'next'):
+        result = {"__type__": "ListNode", "val": _serialize(getattr(obj, 'val', getattr(obj, 'value', None)), depth + 1)}
+        result["next"] = _serialize(obj.next, depth + 1)
+        return result
+    elif callable(obj):
+        return None
+    else:
+        repr_str = repr(obj)
+        if repr_str.startswith('<') and repr_str.endswith('>'):
+            return None
+        return repr_str
+`;
+
+// packages/harness-python/src/python-harness.ts
+function identifyConversions(inputs) {
+  const treeKeys = [];
+  const listKeys = [];
+  for (const [key, value] of Object.entries(inputs)) {
+    if (value && typeof value === "object" && !Array.isArray(value) && ("val" in value || "value" in value)) {
+      const obj = value;
+      const hasLeft = "left" in obj;
+      const hasRight = "right" in obj;
+      const hasNext = "next" in obj;
+      if (hasLeft || hasRight) {
+        treeKeys.push(key);
+      } else if (hasNext) {
+        listKeys.push(key);
+      } else {
+        treeKeys.push(key);
+      }
+    }
+  }
+  return { treeKeys, listKeys };
+}
+function generateConversionCode(inputs) {
+  const { treeKeys, listKeys } = identifyConversions(inputs);
+  const lines = [];
+  for (const key of treeKeys) {
+    lines.push(`${key} = _dict_to_tree(${key})`);
+  }
+  for (const key of listKeys) {
+    lines.push(`${key} = _dict_to_list(${key})`);
+  }
+  return lines.join("\n");
+}
+function generateInputSetup(inputs) {
+  return Object.entries(inputs).map(([key, value]) => `${key} = ${toPythonLiteral(value)}`).join("\n");
+}
+function generateSolutionScript(solutionCode, functionName, inputs) {
+  const inputSetup = generateInputSetup(inputs);
+  const conversionCode = generateConversionCode(inputs);
+  const paramList = Object.keys(inputs).map((key) => `${key}=${key}`).join(", ");
+  return `
+import json
+import sys
+
+${PYTHON_CLASS_DEFINITIONS}
+
+${PYTHON_CONVERSION_HELPERS}
+
+${PYTHON_SERIALIZE_FUNCTION}
+
+# Solution code
+${solutionCode}
+
+# Set up inputs
+${inputSetup}
+
+# Convert tree/list inputs
+${conversionCode}
+
+# Run the function
+try:
+    _result = ${functionName}(${paramList})
+    print(json.dumps({"success": True, "output": _serialize(_result)}))
+except Exception as e:
+    print(json.dumps({"success": False, "error": f"{type(e).__name__}: {str(e)}"}))
+`;
+}
+
+// packages/harness-python/src/python-harness-template.ts
+function templateToPythonLiteral(value) {
+  if (value === null || value === void 0) {
+    return "None";
+  }
+  if (typeof value === "boolean") {
+    return value ? "True" : "False";
+  }
+  if (typeof value === "number") {
+    return String(value);
+  }
+  if (typeof value === "string") {
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) {
+    return "[" + value.map(templateToPythonLiteral).join(", ") + "]";
+  }
+  if (typeof value === "object") {
+    const entries = Object.entries(value).map(([k, v]) => `${JSON.stringify(k)}: ${templateToPythonLiteral(v)}`).join(", ");
+    return "{" + entries + "}";
+  }
+  return JSON.stringify(value);
+}
+var TEMPLATE_PYTHON_CLASS_DEFINITIONS = `
+class TreeNode:
+    def __init__(self, val=0, left=None, right=None):
+        self.val = val
+        self.value = val
+        self.left = left
+        self.right = right
+    def __getitem__(self, key):
+        if key == 'val': return getattr(self, 'val', getattr(self, 'value', None))
+        if key == 'value': return getattr(self, 'value', getattr(self, 'val', None))
+        if key == 'left': return self.left
+        if key == 'right': return self.right
+        raise KeyError(key)
+    def get(self, key, default=None):
+        if key == 'val': return getattr(self, 'val', getattr(self, 'value', default))
+        if key == 'value': return getattr(self, 'value', getattr(self, 'val', default))
+        if key == 'left': return self.left
+        if key == 'right': return self.right
+        return default
+    def __repr__(self):
+        return f"TreeNode({getattr(self, 'val', getattr(self, 'value', None))})"
+
+class ListNode:
+    def __init__(self, val=0, next=None):
+        self.val = val
+        self.value = val
+        self.next = next
+    def __getitem__(self, key):
+        if key == 'val': return getattr(self, 'val', getattr(self, 'value', None))
+        if key == 'value': return getattr(self, 'value', getattr(self, 'val', None))
+        if key == 'next': return self.next
+        raise KeyError(key)
+    def get(self, key, default=None):
+        if key == 'val': return getattr(self, 'val', getattr(self, 'value', default))
+        if key == 'value': return getattr(self, 'value', getattr(self, 'val', default))
+        if key == 'next': return self.next
+        return default
+    def __repr__(self):
+        return f"ListNode({getattr(self, 'val', getattr(self, 'value', None))})"
+`;
+var TEMPLATE_PYTHON_CONVERSION_HELPERS = `
+def _ensure_node_value_aliases(node):
+    if node is None:
+        return node
+    try:
+        has_val = hasattr(node, 'val')
+        has_value = hasattr(node, 'value')
+        if has_value and not has_val:
+            try:
+                setattr(node, 'val', getattr(node, 'value'))
+            except Exception:
+                pass
+        elif has_val and not has_value:
+            try:
+                setattr(node, 'value', getattr(node, 'val'))
+            except Exception:
+                pass
+    except Exception:
+        pass
+    return node
+
+def _dict_to_tree(d):
+    if d is None:
+        return None
+    if not isinstance(d, dict):
+        return d
+    if 'val' not in d and 'value' not in d:
+        return d
+    node = TreeNode(d.get('val', d.get('value', 0)))
+    _ensure_node_value_aliases(node)
+    node.left = _dict_to_tree(d.get('left'))
+    node.right = _dict_to_tree(d.get('right'))
+    return node
+
+def _dict_to_list(d, _refs=None):
+    if _refs is None:
+        _refs = {}
+    if d is None:
+        return None
+    if not isinstance(d, dict):
+        return d
+    if '__ref__' in d:
+        return _refs.get(d.get('__ref__'))
+    if 'val' not in d and 'value' not in d:
+        return d
+    node = ListNode(d.get('val', d.get('value', 0)))
+    _ensure_node_value_aliases(node)
+    node_id = d.get('__id__')
+    if isinstance(node_id, str) and node_id:
+        _refs[node_id] = node
+    node.next = _dict_to_list(d.get('next'), _refs)
+    return node
+`;
+var TEMPLATE_PYTHON_TRACE_SERIALIZE_FUNCTION = `
+# Sentinel to mark skipped values (functions, etc.) - distinct from None
+_SKIP_SENTINEL = "__TRACECODE_SKIP__"
+_MAX_SERIALIZE_DEPTH = 48
+
+def _serialize(obj, depth=0, node_refs=None):
+    if node_refs is None:
+        node_refs = {}
+    if isinstance(obj, (bool, int, str, type(None))):
+        return obj
+    elif isinstance(obj, float):
+        if not math.isfinite(obj):
+            if math.isnan(obj):
+                return "NaN"
+            return "Infinity" if obj > 0 else "-Infinity"
+        return obj
+    if depth > _MAX_SERIALIZE_DEPTH:
+        return "<max depth>"
+    elif isinstance(obj, (list, tuple)):
+        return [_serialize(x, depth + 1, node_refs) for x in obj]
+    elif getattr(obj, '__class__', None) and getattr(obj.__class__, '__name__', '') == 'deque':
+        return [_serialize(x, depth + 1, node_refs) for x in obj]
+    elif isinstance(obj, dict):
+        return {str(k): _serialize(v, depth + 1, node_refs) for k, v in obj.items()}
+    elif isinstance(obj, set):
+        # Use try/except for sorting to handle heterogeneous sets
+        try:
+            sorted_vals = sorted([_serialize(x, depth + 1, node_refs) for x in obj])
+        except TypeError:
+            sorted_vals = [_serialize(x, depth + 1, node_refs) for x in obj]
+        return {"__type__": "set", "values": sorted_vals}
+    elif (hasattr(obj, 'val') or hasattr(obj, 'value')) and (hasattr(obj, 'left') or hasattr(obj, 'right')):
+        obj_ref = id(obj)
+        if obj_ref in node_refs:
+            return {"__ref__": node_refs[obj_ref]}
+        node_id = f"tree-{obj_ref}"
+        node_refs[obj_ref] = node_id
+        result = {
+            "__type__": "TreeNode",
+            "__id__": node_id,
+            "val": _serialize(getattr(obj, 'val', getattr(obj, 'value', None)), depth + 1, node_refs),
+        }
+        if hasattr(obj, 'left'):
+            result["left"] = _serialize(obj.left, depth + 1, node_refs)
+        if hasattr(obj, 'right'):
+            result["right"] = _serialize(obj.right, depth + 1, node_refs)
+        return result
+    elif (hasattr(obj, 'val') or hasattr(obj, 'value')) and hasattr(obj, 'next'):
+        obj_ref = id(obj)
+        if obj_ref in node_refs:
+            return {"__ref__": node_refs[obj_ref]}
+        node_id = f"list-{obj_ref}"
+        node_refs[obj_ref] = node_id
+        result = {
+            "__type__": "ListNode",
+            "__id__": node_id,
+            "val": _serialize(getattr(obj, 'val', getattr(obj, 'value', None)), depth + 1, node_refs),
+        }
+        result["next"] = _serialize(obj.next, depth + 1, node_refs)
+        return result
+    elif callable(obj):
+        # Skip functions entirely - return sentinel
+        return _SKIP_SENTINEL
+    else:
+        repr_str = repr(obj)
+        # Filter out function-like representations (e.g., <function foo at 0x...>)
+        if repr_str.startswith('<') and repr_str.endswith('>'):
+            return _SKIP_SENTINEL
+        return repr_str
+`;
+var TEMPLATE_PYTHON_EXECUTE_SERIALIZE_FUNCTION = `
+_MAX_SERIALIZE_DEPTH = 48
+
+def _serialize(obj, depth=0):
+    if isinstance(obj, (bool, int, str, type(None))):
+        return obj
+    elif isinstance(obj, float):
+        if not math.isfinite(obj):
+            if math.isnan(obj):
+                return "NaN"
+            return "Infinity" if obj > 0 else "-Infinity"
+        return obj
+    if depth > _MAX_SERIALIZE_DEPTH:
+        return "<max depth>"
+    elif isinstance(obj, (list, tuple)):
+        return [_serialize(x, depth + 1) for x in obj]
+    elif getattr(obj, '__class__', None) and getattr(obj.__class__, '__name__', '') == 'deque':
+        return [_serialize(x, depth + 1) for x in obj]
+    elif isinstance(obj, dict):
+        return {str(k): _serialize(v, depth + 1) for k, v in obj.items()}
+    elif isinstance(obj, set):
+        try:
+            return {"__type__": "set", "values": sorted([_serialize(x, depth + 1) for x in obj])}
+        except TypeError:
+            return {"__type__": "set", "values": [_serialize(x, depth + 1) for x in obj]}
+    elif (hasattr(obj, 'val') or hasattr(obj, 'value')) and (hasattr(obj, 'left') or hasattr(obj, 'right')):
+        result = {"__type__": "TreeNode", "val": _serialize(getattr(obj, 'val', getattr(obj, 'value', None)), depth + 1)}
+        if hasattr(obj, 'left'):
+            result["left"] = _serialize(obj.left, depth + 1)
+        if hasattr(obj, 'right'):
+            result["right"] = _serialize(obj.right, depth + 1)
+        return result
+    elif (hasattr(obj, 'val') or hasattr(obj, 'value')) and hasattr(obj, 'next'):
+        result = {"__type__": "ListNode", "val": _serialize(getattr(obj, 'val', getattr(obj, 'value', None)), depth + 1)}
+        result["next"] = _serialize(obj.next, depth + 1)
+        return result
+    elif callable(obj):
+        return None
+    else:
+        repr_str = repr(obj)
+        if repr_str.startswith('<') and repr_str.endswith('>'):
+            return None
+        return repr_str
+`;
+var TEMPLATE_PYTHON_PRACTICE_MATERIALIZE_SERIALIZE_FUNCTION = `
+def _serialize(obj, depth=0, state=None):
+    if state is None:
+        state = {"nodes": 0, "seen": set()}
+    if depth > 64:
+        return "__MAX_DEPTH__"
+    if isinstance(obj, (int, float, str, bool, type(None))):
+        return obj
+
+    state["nodes"] += 1
+    if state["nodes"] > 600:
+        return "__MAX_NODES__"
+
+    if isinstance(obj, (list, tuple)):
+        return [_serialize(x, depth + 1, state) for x in obj]
+    elif isinstance(obj, dict):
+        return {str(k): _serialize(v, depth + 1, state) for k, v in obj.items()}
+    elif isinstance(obj, set):
+        serialized = [_serialize(x, depth + 1, state) for x in obj]
+        try:
+            serialized = sorted(serialized)
+        except TypeError:
+            pass
+        return {"__type__": "set", "values": serialized}
+    elif (hasattr(obj, 'val') or hasattr(obj, 'value')) and (hasattr(obj, 'left') or hasattr(obj, 'right')):
+        obj_id = id(obj)
+        if obj_id in state["seen"]:
+            return "__CYCLE__"
+        state["seen"].add(obj_id)
+        result = {"__type__": "TreeNode", "val": _serialize(getattr(obj, 'val', getattr(obj, 'value', None)), depth + 1, state)}
+        if hasattr(obj, 'left'):
+            result["left"] = _serialize(obj.left, depth + 1, state)
+        if hasattr(obj, 'right'):
+            result["right"] = _serialize(obj.right, depth + 1, state)
+        state["seen"].remove(obj_id)
+        return result
+    elif (hasattr(obj, 'val') or hasattr(obj, 'value')) and hasattr(obj, 'next'):
+        obj_id = id(obj)
+        if obj_id in state["seen"]:
+            return "__CYCLE__"
+        state["seen"].add(obj_id)
+        result = {"__type__": "ListNode", "val": _serialize(getattr(obj, 'val', getattr(obj, 'value', None)), depth + 1, state)}
+        result["next"] = _serialize(obj.next, depth + 1, state)
+        state["seen"].remove(obj_id)
+        return result
+    else:
+        return repr(obj)
+`;
+var TEMPLATE_PYTHON_INTERVIEW_MATERIALIZE_SERIALIZE_FUNCTION = `
+def _serialize(obj, depth=0):
+    if depth > 10:
+        return "<max depth>"
+    if isinstance(obj, (int, float, str, bool, type(None))):
+        return obj
+    elif isinstance(obj, (list, tuple)):
+        return [_serialize(x, depth + 1) for x in obj]
+    elif isinstance(obj, dict):
+        return {str(k): _serialize(v, depth + 1) for k, v in obj.items()}
+    elif isinstance(obj, set):
+        try:
+            return {"__type__": "set", "values": sorted([_serialize(x, depth + 1) for x in obj])}
+        except TypeError:
+            return {"__type__": "set", "values": [_serialize(x, depth + 1) for x in obj]}
+    elif hasattr(obj, 'val') and (hasattr(obj, 'left') or hasattr(obj, 'right')):
+        result = {"__type__": "TreeNode", "val": _serialize(getattr(obj, 'val', None), depth + 1)}
+        if hasattr(obj, 'left'):
+            result["left"] = _serialize(obj.left, depth + 1)
+        if hasattr(obj, 'right'):
+            result["right"] = _serialize(obj.right, depth + 1)
+        return result
+    elif hasattr(obj, 'val') and hasattr(obj, 'next'):
+        result = {"__type__": "ListNode", "val": _serialize(getattr(obj, 'val', None), depth + 1)}
+        result["next"] = _serialize(obj.next, depth + 1)
+        return result
+    else:
+        return repr(obj)
+`;
+var TEMPLATE_PYTHON_SERIALIZE_FUNCTION = TEMPLATE_PYTHON_EXECUTE_SERIALIZE_FUNCTION;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PYTHON_CLASS_DEFINITIONS,
+  PYTHON_CONVERSION_HELPERS,
+  PYTHON_EXECUTE_SERIALIZE_FUNCTION,
+  PYTHON_INTERVIEW_MATERIALIZE_SERIALIZE_FUNCTION,
+  PYTHON_PRACTICE_MATERIALIZE_SERIALIZE_FUNCTION,
+  PYTHON_SERIALIZE_FUNCTION,
+  PYTHON_TRACE_SERIALIZE_FUNCTION,
+  TEMPLATE_PYTHON_CLASS_DEFINITIONS,
+  TEMPLATE_PYTHON_CONVERSION_HELPERS,
+  TEMPLATE_PYTHON_EXECUTE_SERIALIZE_FUNCTION,
+  TEMPLATE_PYTHON_INTERVIEW_MATERIALIZE_SERIALIZE_FUNCTION,
+  TEMPLATE_PYTHON_PRACTICE_MATERIALIZE_SERIALIZE_FUNCTION,
+  TEMPLATE_PYTHON_SERIALIZE_FUNCTION,
+  TEMPLATE_PYTHON_TRACE_SERIALIZE_FUNCTION,
+  generateConversionCode,
+  generateInputSetup,
+  generateSolutionScript,
+  identifyConversions,
+  templateToPythonLiteral,
+  toPythonLiteral
+});
+//# sourceMappingURL=python.cjs.map