| extract_all_domains_problems |
Ran ran on a synthesized input |
qxcv/asnets/asnets/asnets/pddl_utils.py code served (permissive licence) · get_code("1d44813d2c760247") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple, ndim 1, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import tempfile
import os
# Create temporary PDDL files for testing
temp_dir = tempfile.mkdtemp()
# Create a simple domain PDDL file
domain_pddl = """
(define (domain simple-domain)
(:requirements :strips :typing)
(:types location - object)
(:predicates (at ?obj - object ?loc - location))
(:action move
:parameters (?from ?to - location)
:precondition (at ?obj ?from)
:effect (at ?obj ?to)))
"""
# Create a simple problem PDDL file
problem_pddl = """
(define (problem simple-problem)
(:domain simple-domain)
(:objects
loc1 loc2 - location)
(:init
(at obj loc1))
(:goal
(at obj loc2)))
"""
# Write files
domain_file = os.path.join(temp_dir, "domain.pddl")
problem_file = os.path.join(temp_dir, "problem.pddl")
with open(domain_file, 'w') as f:
f.write(domain_pddl)
with open(problem_file, 'w') as f:
f.write(problem_pddl)
# Create list of PDDL files
pddl_files = [domain_file, problem_file]
ARGS = {
'pddl_files': pddl_files
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type tuple, ndim 1, dtype family float — a tuple output has no array shape of its own; none is stated
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| find_tail_cycle |
Ran ran on a synthesized input |
qxcv/asnets/asnets/asnets/py_utils.py code served (permissive licence) · get_code("01894c8c99a5c3bc") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
# Test case 1: Simple repeating cycle at the end
item_list_1 = [1, 2, 3, 1, 2, 1, 2, 1, 2]
max_cycle_len_1 = 3
# Test case 2: No cycle
item_list_2 = [1, 2, 3, 4, 5]
max_cycle_len_2 = 3
# Test case 3: Longer repeating pattern
item_list_3 = ['a', 'b', 'c', 'd', 'a', 'b', 'c', 'a', 'b', 'c']
max_cycle_len_3 = 5
# Use the first test case as the main example
ARGS = {
"item_list": [1, 2, 1, 2, 1, 2],
"max_cycle_len": 3
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type tuple — a tuple output has no array shape of its own; none is stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| format_state_for_ssipp |
Ran ran on a synthesized input |
qxcv/asnets/asnets/asnets/ssipp_interface.py code served (permissive licence) · get_code("ca7dfed8da5f2147") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned str. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
class PropObject:
def __init__(self, identifier):
self.identifier = identifier
# Create test prop objects with valid SSiPP format
prop1 = PropObject("(at robot loc1)")
prop2 = PropObject("(holding obj1)")
prop3 = PropObject("(clear loc2)")
# Create all_props list with (prop_obj, truth) tuples
# Include both True and False values to test the filtering logic
all_props = [
(prop1, True),
(prop2, False),
(prop3, True),
]
ARGS = {
"all_props": all_props,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type str — a str output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a str output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| get_plan_file_path |
Ran ran on a synthesized input |
qxcv/asnets/asnets/asnets/fd_interface.py code served (permissive licence) · get_code("d92b7dc4a1776ba4") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned str. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import os
import tempfile
import shutil
# Create a temporary directory with test files
temp_dir = tempfile.mkdtemp()
# Create test plan files
# Case 1: Simple plan file (non-anytime planner)
with open(os.path.join(temp_dir, "sas_plan"), "w") as f:
f.write("dummy plan content")
# Case 2: Anytime planner files with stage numbers
with open(os.path.join(temp_dir, "sas_plan.1"), "w") as f:
f.write("stage 1 plan")
with open(os.path.join(temp_dir, "sas_plan.2"), "w") as f:
f.write("stage 2 plan")
with open(os.path.join(temp_dir, "sas_plan.5"), "w") as f:
f.write("stage 5 plan")
# Define arguments
ARGS = {
"root_dir": temp_dir,
"base_name": "sas_plan"
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type str — a str output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a str output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| make_bound_prop |
Ran ran on a synthesized input |
qxcv/asnets/asnets/asnets/prob_dom_meta.py code served (permissive licence) · get_code("8db9068b171ab385") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned BoundProp. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import numpy as np
from functools import lru_cache, total_ordering
torch.manual_seed(0)
# Create a minimal stand-in class for a term with a name attribute
class Term:
def __init__(self, name):
self.name = name
# Create a minimal stand-in class for a predicate with a name attribute
class Predicate:
def __init__(self, name):
self.name = name
# Create a minimal stand-in class for a ground proposition with predicate and terms
class GroundProp:
def __init__(self, predicate, terms):
self.predicate = predicate
self.terms = terms
# Construct the mdpsim_ground_prop argument
pred = Predicate("at")
term1 = Term("robot")
term2 = Term("location_a")
mdpsim_ground_prop = GroundProp(pred, [term1, term2])
ARGS = {
"mdpsim_ground_prop": mdpsim_ground_prop
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type BoundProp — a BoundProp output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a BoundProp output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| make_unbound_prop |
Ran ran on a synthesized input |
qxcv/asnets/asnets/asnets/prob_dom_meta.py code served (permissive licence) · get_code("c70adc0ea5536072") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned UnboundProp. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import numpy as np
from functools import lru_cache, total_ordering
class UnboundProp:
"""Represents a proposition which may have free parameters (e.g. as it will
in an action). .bind() will ground it."""
def __init__(self, pred_name, params):
self.pred_name = pred_name
self.params = tuple(params)
assert isinstance(self.pred_name, str)
assert all((isinstance(p, str) for p in self.params))
def __repr__(self):
return 'UnboundProp(%r, %r)' % (self.pred_name, self.params)
def bind(self, bindings):
assert isinstance(bindings, dict), 'expected dict of named bindings'
args = []
for param_name in self.params:
if param_name[0] != '?':
arg = param_name
else:
if param_name not in bindings:
raise ValueError("needed bind for parameter %s, didn't get one" % param_name)
arg = bindings[param_name]
args.append(arg)
return BoundProp(self.pred_name, args)
def __eq__(self, other):
if not isinstance(other, UnboundProp):
return NotImplemented
return self.pred_name == other.pred_name and self.params == other.params
def __hash__(self):
return hash(self.pred_name) ^ hash(self.params)
@total_ordering
class BoundProp:
"""Represents a ground proposition."""
def __init__(self, pred_name, arguments):
self.pred_name = pred_name
self.arguments = tuple(arguments)
self.unique_ident = self._compute_unique_ident()
assert isinstance(self.pred_name, str)
assert all((isinstance(p, str) for p in self.arguments))
def __repr__(self):
return 'BoundProp(%r, %r)' % (self.pred_name, self.arguments)
def _compute_unique_ident(self):
unique_id = ' '.join((self.pred_name,) + self.arguments)
return unique_id
def __eq__(self, other):
if not isinstance(other, BoundProp):
return NotImplemented
return self.unique_ident == other.unique_ident
def __lt__(self, other):
if not isinstance(other, BoundProp):
return NotImplemented
return self.unique_ident < other.unique_ident
def __hash__(self):
return hash(self.unique_ident)
def make_unbound_prop(mdpsim_lifted_prop):
pred_name = mdpsim_lifted_prop.predicate.name
terms = [t.name for t in mdpsim_lifted_prop.terms]
return UnboundProp(pred_name, terms)
class MockTerm:
def __init__(self, name):
self.name = name
class MockPredicate:
def __init__(self, name):
self.name = name
class MockLiftedProp:
def __init__(self, predicate_name, term_names):
self.predicate = MockPredicate(predicate_name)
self.terms = [MockTerm(name) for name in term_names]
ARGS = {
'mdpsim_lifted_prop': MockLiftedProp('on', ['block_a', 'block_b'])
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type UnboundProp — a UnboundProp output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a UnboundProp output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| parse_problem_args |
Ran ran on a synthesized input |
qxcv/asnets/asnets/asnets/mdpsim_utils.py code served (permissive licence) · get_code("fab473cbc462543e") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned dict. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import numpy as np
class MockMDPSimModule:
"""Mock mdpsim module for testing parse_problem_args"""
def __init__(self):
self.files_parsed = []
self.problems = {
'problem_1': {'name': 'problem_1', 'state': [1, 2, 3]},
'problem_2': {'name': 'problem_2', 'state': [4, 5, 6]},
}
def parse_file(self, pddl_path):
"""Simulate parsing a PDDL file"""
self.files_parsed.append(pddl_path)
# Return True for successful parse
return True
def get_problems(self):
"""Return the loaded problems dictionary"""
return self.problems
# Create mock module instance
mdpsim_module = MockMDPSimModule()
# Create list of PDDL file paths (as strings, no actual file I/O)
pddls = [
'/path/to/domain.pddl',
'/path/to/problem.pddl'
]
# Define ARGS dict with all parameters
ARGS = {
'mdpsim_module': mdpsim_module,
'pddls': pddls,
'problem_name': 'problem_1'
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type dict — a dict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a dict output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| parse_sexprs |
Ran ran on a synthesized input |
qxcv/asnets/asnets/asnets/pddl_utils.py code served (permissive licence) · get_code("eba72f2486b730d0") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned HList. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import re
import weakref
def _ppddl_tokenize(ppddl_txt):
"""Break PPDDL into tokens (brackets, non-bracket chunks)"""
lines = ppddl_txt.splitlines()
mod_lines = []
for line in lines:
try:
semi_idx = line.index(';')
except ValueError:
pass
else:
line = line[:semi_idx]
mod_lines.append(line)
ppddl_txt = '\n'.join(mod_lines)
ppddl_txt = ppddl_txt.lower()
matches = re.findall('\\(|\\)|[^\\s\\(\\)]+', ppddl_txt)
return matches
class HList(list):
"""Class for hierarchical list. Helpful because you can get at parent from
current node (or see that current node is root if no parent)."""
def __init__(self, parent):
super().__init__()
self.is_root = parent is None
self._parent_ref = weakref.ref(parent) if not self.is_root else None
@property
def parent(self):
if self.is_root:
return None
return self._parent_ref()
def parse_sexprs(ppddl_txt):
"""Hacky parse of sexprs from ppddl."""
tokens = _ppddl_tokenize(ppddl_txt)
parse_root = parse_ptr = HList(None)
tokens_reverse = tokens[::-1]
while tokens_reverse:
token = tokens_reverse.pop()
if token == '(':
new_ptr = HList(parse_ptr)
parse_ptr.append(new_ptr)
parse_ptr = new_ptr
elif token == ')':
parse_ptr = parse_ptr.parent
else:
parse_ptr.append(token)
return parse_root
ppddl_txt = """
(define (domain blocksworld)
(:requirements :strips :typing)
(:types block)
(:predicates (on ?x ?y) (clear ?x))
(:action move
:parameters (?x ?y ?z - block)
:precondition (and (on ?x ?y) (clear ?x))
:effect (and (on ?x ?z) (not (on ?x ?y)))))
"""
ARGS = {
"ppddl_txt": ppddl_txt
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type HList — a HList output has no array shape of its own; none is stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| set_up_ssipp |
Ran ran on a synthesized input |
qxcv/asnets/asnets/asnets/ssipp_interface.py code served (permissive licence) · get_code("29bb436de3ba7e0b") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned dict. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import numpy as np
from unittest.mock import Mock, MagicMock
class MockSSIPPModule:
"""Mock SSIPP module that simulates PDDL parsing and problem initialization."""
def __init__(self):
self.files_read = []
self.pddl_data = {}
def readPDDLFile(self, file_path):
"""Mock method to read PDDL files."""
self.files_read.append(file_path)
self.pddl_data[file_path] = f"parsed_content_of_{file_path}"
def init_problem(self, problem_name):
"""Mock method to initialize a problem from parsed PDDL."""
problem = {
"name": problem_name,
"domain": "logistics",
"objects": ["truck1", "package1", "location1"],
"initial_state": {"at": [("truck1", "location1")]},
"goal": {"at": [("package1", "location1")]}
}
return problem
# Create mock SSIPP module instance
ssipp_module = MockSSIPPModule()
# Create mock PDDL file paths (no actual files needed)
pddl_paths = [
"/mock/domain.pddl",
"/mock/problem.pddl"
]
# Define problem name
problem_name = "logistics_problem_1"
# Construct ARGS dict with all required parameters
ARGS = {
"ssipp_module": ssipp_module,
"pddl_paths": pddl_paths,
"problem_name": problem_name
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type dict — a dict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a dict output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| strip_parens |
Ran ran on a synthesized input |
qxcv/asnets/asnets/asnets/py_utils.py code served (permissive licence) · get_code("2776f2994efc5176") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned str. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
def strip_parens(thing):
"""Convert string of form `(foo bar baz)` to `foo bar baz` (i.e. strip
leading & trailing parens). More complicated than it should be b/c it does
safety checks to catch my bugs :)"""
assert len(thing) > 2 and thing[0] == '(' and (thing[-1] == ')'), "'%s' does not look like it's surrounded by parens" % (thing,)
stripped = thing[1:-1]
assert '(' not in stripped and ')' not in stripped, "parens in '%s' aren't limited to start and end" % (thing,)
return stripped
ARGS = {
'thing': '(foo bar baz)'
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type str — a str output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a str output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| to_local |
Ran ran on a synthesized input |
qxcv/asnets/asnets/asnets/multiprob.py code served (permissive licence) · get_code("211a1968113927a3") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned dict. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
from copy import deepcopy
torch.manual_seed(0)
# The function `to_local` takes a single parameter `obj` and returns deepcopy(obj)
# It doesn't call any methods on obj, just deepcopies it
# We can pass any serializable object
# Create a diverse test object that can be deepcopied
test_obj = {
"tensor": torch.randn(2, 4),
"list": [1, 2, 3],
"nested_dict": {"a": 10, "b": torch.randn(3, 4)},
"string": "hello",
"number": 42,
}
ARGS = {
"obj": test_obj
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type dict — a dict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a dict output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| weak_ref_to |
Ran ran on a synthesized input |
qxcv/asnets/asnets/asnets/py_utils.py code served (permissive licence) · get_code("ef639be154fac681") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ProxyType. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
from weakref import proxy, ProxyTypes
# Test with a simple object that can be weakly referenced
class SimpleObject:
def __init__(self, value):
self.value = value
# Create a real object
obj = SimpleObject(42)
# Create a weak reference to it
weak_ref = proxy(obj)
# Test case 1: passing a regular object
regular_object = SimpleObject(100)
# Test case 2: passing None
none_value = None
# Test case 3: passing an existing weak reference
existing_weak_ref = proxy(SimpleObject(200))
# Map all parameters to values
ARGS = {
'obj': regular_object
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type ProxyType — a ProxyType output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a ProxyType output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| can_profile |
Not yet run unverified (harvested, no recorded run) |
qxcv/asnets/asnets/asnets/prof_utils.py code served (permissive licence) · get_code("f3b50583da62f483") How it ran |
| hlist_to_sexprs |
Not yet run unverified (harvested, no recorded run) |
qxcv/asnets/asnets/asnets/pddl_utils.py code served (permissive licence) · get_code("4460d2adcc6338aa") How it ran |
| make_unbound_action |
Not yet run unverified (harvested, no recorded run) |
qxcv/asnets/asnets/asnets/prob_dom_meta.py code served (permissive licence) · get_code("facfe8f2ba36c6f5") How it ran |
| run_fd_or_timeout |
Not yet run unverified (harvested, no recorded run) |
qxcv/asnets/asnets/asnets/fd_interface.py code served (permissive licence) · get_code("5ee146b62834fec7") How it ran |
| run_fd_raw |
Not yet run unverified (harvested, no recorded run) |
qxcv/asnets/asnets/asnets/fd_interface.py code served (permissive licence) · get_code("7434fe8e7707e998") How it ran |
| wait_exists_polling |
Not yet run unverified (harvested, no recorded run) |
qxcv/asnets/asnets/asnets/multiprob.py code served (permissive licence) · get_code("004f8baf6f764d3b") How it ran |