| import json,re,ast,sys,subprocess,concurrent.futures |
| from pathlib import Path |
| D=Path("dataset-repair");data=json.loads((D/"retained.json").read_text()) |
| fixtures=[ |
| ("remove consecutive duplicate readings",[([1,1,2,2,1],),([],)],[[1,2,1],[]]), |
| ("find items shared by two lists",[(["b","a","c"],["a","b"]),(["x"],["y"])],[["b","a"],[]]), |
| ("rotate a list by an integer offset",[([1,2,3,4],2),([],3)],[[3,4,1,2],[]]), |
| ("rank distinct labels by descending frequency",[(["b","a","b","a","c"],)],[{"one_of":[["a","b","c"],[["a",2],["b",2],["c",1]]]}]), |
| ("count distinct nonempty names",[([" Ana ","Ana"," Bo ",""," "],)], [2]), |
| ("split a sequence into fixed-size chunks",[([1,2,3,4,5],2),([],2)],[[[1,2],[3,4],[5]],[]]), |
| ("return the first missing positive integer",[([3,4,-1,1],),([],),([1,2,0],)],[2,1,3]), |
| ("compute cumulative totals",[([1,-2,3],),([],)],[[1,-1,2],[]]), |
| ("return indices where a sequence changes value",[([2,2,4,4,1],),([],)],[[2,4],[]]), |
| ("validate a minutes:seconds duration",[("03:05",),("0:00",),("4:60",)],[185,0,{"raises":"ValueError"}]), |
| ("calculate moving averages",[([1,2,3,4],2)],[ [1.5,2.5,3.5] ]), |
| ("keep the first occurrence of every hashable item",[([1,1,2,1,3],)],[[1,2,3]]), |
| ("flatten a list of lists",[([[],[1,2],[3]],)],[[1,2,3]]), |
| ("parse nonempty comma-separated labels",[(" a, , b ",)],[["a","b"]]), |
| ("merge overlapping closed integer intervals",[([(1,3),(2,4),(6,7)],),([],)],[[[1,4],[6,7]],[]]) |
| ] |
| harness=r''' |
| import sys,json,ast,copy,math,statistics,collections,itertools,re,resource |
| resource.setrlimit(resource.RLIMIT_CPU,(1,1)) |
| resource.setrlimit(resource.RLIMIT_AS,(192*1024*1024,192*1024*1024)) |
| payload=json.loads(sys.stdin.read());tree=ast.parse(payload["code"]) |
| class StripTypes(ast.NodeTransformer): |
| def visit_ImportFrom(self,node):return None if node.module in {"typing","__future__"} else node |
| def visit_Import(self,node): |
| node.names=[x for x in node.names if x.name!="typing"] |
| return node if node.names else None |
| def visit_arg(self,node):node.annotation=None;return node |
| def visit_FunctionDef(self,node): |
| node.returns=None;self.generic_visit(node);return node |
| def visit_AnnAssign(self,node):return ast.Assign(targets=[node.target],value=node.value) if node.value is not None else ast.Pass() |
| tree=ast.fix_missing_locations(StripTypes().visit(tree)) |
| allowed_imports={"math":math,"statistics":statistics,"collections":collections,"itertools":itertools,"re":re} |
| for node in ast.walk(tree): |
| if isinstance(node,ast.Attribute) and node.attr.startswith("_"):raise RuntimeError("restricted attribute") |
| if isinstance(node,ast.Name) and node.id.startswith("__"):raise RuntimeError("restricted name") |
| if isinstance(node,(ast.ClassDef,ast.AsyncFunctionDef)):raise RuntimeError("unsupported construct") |
| if isinstance(node,ast.Import) and any(x.name not in allowed_imports for x in node.names):print(json.dumps({"passed":None}));sys.exit(0) |
| if isinstance(node,ast.ImportFrom) and node.module not in allowed_imports:print(json.dumps({"passed":None}));sys.exit(0) |
| def importer(name,*a,**kw): |
| if name not in allowed_imports:raise ImportError(name) |
| return allowed_imports[name] |
| import builtins |
| names=["int","float","str","bool","dict","list","tuple","set","range","enumerate","len","zip","map","filter","any","all","min","max","sum","sorted","abs","round","isinstance","ValueError","TypeError","IndexError","Exception","iter","next","reversed"] |
| scope={"__builtins__":{k:getattr(builtins,k) for k in names}} |
| scope["__builtins__"]["__import__"]=importer |
| exec(compile(tree,"sample.py","exec"),scope) |
| def canonical(v): |
| if isinstance(v,(tuple,list)) or (hasattr(v,"__iter__") and not isinstance(v,(str,bytes,dict))):return [canonical(x) for x in v] |
| return v |
| passed=False |
| for node in tree.body: |
| if not isinstance(node,ast.FunctionDef):continue |
| fn=scope[node.name] |
| try: |
| matches=True |
| for args,expected in zip(payload["args"],payload["expected"]): |
| original=copy.deepcopy(args);callargs=copy.deepcopy(args) |
| params=[p.arg.lower() for p in node.args.args] |
| if len(callargs)==1 and isinstance(callargs[0],str) and re.fullmatch(r"\d+:\d+",callargs[0]) and len(params)>=2: |
| callargs=[int(x) for x in callargs[0].split(":")] |
| elif len(callargs)==2 and isinstance(callargs[0],list) and isinstance(callargs[1],int) and params and any(x in params[0] for x in ["size","window","width","chunk"]): |
| callargs=callargs[::-1] |
| expected_original=copy.deepcopy(callargs) |
| try:result=fn(*callargs) |
| except ValueError: |
| if expected=={"raises":"ValueError"}:continue |
| raise |
| if expected=={"raises":"ValueError"}:matches=False;break |
| if payload.get("immutable") and callargs!=expected_original:matches=False;break |
| if isinstance(expected,dict) and "one_of" in expected: |
| if not any(canonical(result)==canonical(v) for v in expected["one_of"]):matches=False;break |
| elif canonical(result)!=canonical(expected):matches=False;break |
| if matches:passed=True;break |
| except Exception:continue |
| print(json.dumps({"passed":passed})) |
| ''' |
| fence=chr(96)*3 |
| tasks=[] |
| for key,rows in data.items(): |
| if not key.startswith("original/"):continue |
| for row in rows: |
| if row["category"]!="coding":continue |
| for needle,args,expected in fixtures: |
| if needle in row["instruction"].lower(): |
| match=re.search(fence+r"(?:python)?\s*(.*?)"+fence,row["response"],re.S) |
| code=match.group(1).strip() if match else row["response"] |
| tasks.append((row["id"],{"code":code,"args":args,"expected":expected,"immutable":"Do not mutate the supplied input" in row["instruction"]}));break |
| def check(item): |
| ident,payload=item |
| try: |
| r=subprocess.run([sys.executable,"-I","-c",harness],input=json.dumps(payload),capture_output=True,text=True,timeout=2,env={"PATH":"/usr/bin:/bin"}) |
| outcome=json.loads(r.stdout) if r.returncode==0 else {"passed":False} |
| return ident,outcome["passed"] |
| except (ValueError,subprocess.TimeoutExpired):return ident,False |
| with concurrent.futures.ThreadPoolExecutor(max_workers=2) as pool:results=dict(pool.map(check,tasks)) |
| failed={k for k,v in results.items() if v is False} |
| for key,rows in data.items(): |
| if key.startswith("original/"):data[key]=[r for r in rows if r["id"] not in failed] |
| (D/"retained_semantic.json").write_text(json.dumps(data,ensure_ascii=False)) |
| report={"tested_records":len(results),"passed":sum(v is True for v in results.values()),"unsupported":sum(v is None for v in results.values()),"failed":len(failed),"failed_ids":sorted(failed),"test_method":"Task-specific functional fixtures in restricted child processes with CPU, memory and wall-time limits"} |
| (D/"code_quality.json").write_text(json.dumps(report,indent=2)) |
| print(json.dumps({k:v for k,v in report.items() if k!="failed_ids"},indent=2)) |
|
|
