| basedir |
Ran ran; our contract draft was wrong, not the code |
plasma-umass/coverup-eval/output/cm/ansible/coverup-tests/disabled_test_coverup_1137.py code served (permissive licence) · get_code("e780f2ac9b06a8c2") 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 basedir(source):
return '/fake/dir'
ARGS = {
'source': '/some/path'
}
- 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
|
| count_tokens |
Ran ran, honoured the contract we drafted |
plasma-umass/coverup/src/coverup/llm.py code served (permissive licence) · get_code("145acc26153dc1f4") 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 int, ndim 0, dtype family int, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape 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 torch.nn as nn
torch.manual_seed(0)
# The function uses:
# - model_name: str - passed to token_counter
# - completion: dict with 'messages' key - messages are passed to token_counter
# The token_counter function expects messages in a chat format
ARGS = {
"model_name": "gpt-3.5-turbo",
"completion": {
"messages": [
{"role": "user", "content": "Hello, how are you?"},
{"role": "assistant", "content": "I'm doing well, thank you for asking!"}
]
}
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- litellm, torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type int, ndim 0, dtype family int, shape () — shape () as a later run recorded it
- 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
|
| custom_object_representer |
Ran ran; our contract draft was wrong, not the code |
plasma-umass/coverup-eval/output/cm/ansible/coverup-tests/disabled_test_coverup_1108.py code served (permissive licence) · get_code("ae89c975e4a8f393") 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 ScalarNode. 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 yaml
torch.manual_seed(0)
class CustomDumper(yaml.Dumper):
pass
class CustomObject:
pass
dumper = CustomDumper(stream=None)
data = CustomObject()
ARGS = {
'dumper': dumper,
'data': data
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch, yaml — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type ScalarNode — a ScalarNode output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a ScalarNode 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
|
| format_ranges |
Ran ran; our contract draft was wrong, not the code |
plasma-umass/coverup/src/coverup/utils.py code served (permissive licence) · get_code("ecca514f32bdaa28") 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 typing as T
# The function format_ranges takes two parameters:
# - lines: T.Set[int] - a set of line numbers to format
# - negative: T.Set[int] - a set of line numbers to exclude from ranges
# Create test sets of integers
lines = {1, 2, 3, 5, 6, 10, 15, 16, 17}
negative = {4, 7, 8, 9}
ARGS = {
"lines": lines,
"negative": negative,
}
- 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_global_imports |
Ran ran; our contract draft was wrong, not the code |
plasma-umass/coverup/src/coverup/codeinfo.py code served (permissive licence) · get_code("6f9ea5e7c5e3e194") 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 list, 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 ast
from pathlib import Path
import tempfile
import sys
# Create a temporary directory to simulate a package structure
temp_dir = tempfile.mkdtemp()
temp_path = Path(temp_dir)
# Add temp_dir to sys.path so _package_path can find it
sys.path.insert(0, temp_dir)
# Create a simple package structure
package_dir = temp_path / "mypackage"
package_dir.mkdir()
(package_dir / "__init__.py").write_text("")
# Create a test module file within the package
test_module_file = package_dir / "test_module.py"
test_module_code = """
import os
from pathlib import Path
from typing import List
def my_function(x: int) -> str:
return str(x)
class MyClass:
def __init__(self):
pass
"""
test_module_file.write_text(test_module_code)
# Parse the module code into an AST
parsed_ast = ast.parse(test_module_code)
# Create a Module instance with the parsed AST and the file path
module = ast.Module(parsed_ast.body, parsed_ast.type_ignores)
custom_module = type('Module', (ast.Module,), {
'path': test_module_file,
'__init__': lambda self, body, type_ignores: ast.Module.__init__(self, body, type_ignores)
})(parsed_ast.body, parsed_ast.type_ignores)
custom_module.path = test_module_file
# Create a node to search for - we'll use a simple Name node
# that references one of the imported names
node = ast.parse("os.getcwd()").body[0]
ARGS = {
'module': custom_module,
'node': node,
}
- 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 list, ndim 1, dtype family float — a list 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
|
| is_same_as_P |
Ran ran, violated the contract we drafted |
plasma-umass/coverup/src/coverup/logreader.py code served (permissive licence) · get_code("218a7174bbbafd7c") 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 bool, ndim 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape 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
def is_same_as_P(content, begin, end):
"""Attempts to detect 'C' (context) prompts that were only issued as context prompts
because their 'def' executed when their module was loaded to 'P' (initial) prompts,
which is what they should have been."""
begin, end = (int(begin), int(end))
if (rng := re.search('^when tested, lines (\\d+)-(\\d+) do not execute', content, re.M)) and (py := re.search('```python\\n(.*)```', content, re.S)):
first, last = (int(rng.group(1)), int(rng.group(2)))
def del_line_markup(s):
line_markup_len = 12
s = '\n'.join((l[line_markup_len:] for l in s.splitlines()))
import textwrap
return textwrap.dedent(s)
try:
import ast
tree = ast.parse(del_line_markup(py.group(1)))
block = next(iter((node for node in ast.walk(tree) if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)))), None)
if block is None:
block = next(iter((node for node in ast.walk(tree) if isinstance(node, ast.ClassDef))))
except Exception:
print('----')
print(py.group(1))
print('----')
print(del_line_markup(py.group(1)))
print('----')
raise
if ast.get_docstring(block, clean=False) is not None:
block.body.pop(0)
for first_stmt in block.body:
if not isinstance(first_stmt, (ast.Global, ast.Nonlocal)):
break
last_stmt = block.body[-1]
block.lineno = min([block.lineno, *(d.lineno for d in block.decorator_list)])
if begin - 1 + first_stmt.lineno == first and (begin - 1 + last_stmt.lineno <= last and begin - 1 + last_stmt.end_lineno >= last):
return True
elif begin - block.lineno + first_stmt.lineno == first and (begin - block.lineno + last_stmt.lineno <= last and begin - block.lineno + last_stmt.end_lineno >= last):
return True
return False
content = """when tested, lines 2-5 do not execute
def example_func():
x = 1
y = 2
z = 3
return x + y + z
"""
begin = 1
end = 10
ARGS = {
"content": content,
"begin": begin,
"end": end,
}
- 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 bool, ndim 0, dtype family float, shape () — shape () as a later run recorded it
- 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
|
| lines_branches_do |
Ran ran; our contract draft was wrong, not the code |
plasma-umass/coverup/src/coverup/utils.py code served (permissive licence) · get_code("ec9b4903be33464d") 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.
# Setup code for format_ranges and lines_branches_do
ARGS = {
"lines": {1, 3, 5, 7},
"neg_lines": {4, 6},
"branches": {(10, 11), (12, 0), (15, 16)}
}
- 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
|
| parse_file |
Ran ran; our contract draft was wrong, not the code |
plasma-umass/coverup/src/coverup/codeinfo.py code served (permissive licence) · get_code("7bb4f87378c340a8") 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 Module. 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 ast
from pathlib import Path
import tempfile
# Create a temporary Python file with valid Python code
with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as f:
f.write("""
def hello_world():
x = 42
return x
class MyClass:
def __init__(self):
self.value = 10
""")
temp_file_path = Path(f.name)
ARGS = {
"file": temp_file_path
}
- 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 Module — a Module output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Module 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
|
| remove_omit |
Ran ran; our contract draft was wrong, not the code |
plasma-umass/coverup-eval/output/cm/ansible/coverup-tests/disabled_test_coverup_1123.py code served (permissive licence) · get_code("e134f05ecc5345c7") 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
torch.manual_seed(0)
# The function remove_omit takes a dictionary and an omit_token,
# and returns a new dictionary with all entries where v != omit_token removed.
# It uses:
# - d.items() to iterate over key-value pairs
# - comparison operator != with omit_token
# Create a simple dictionary with various values
d = {
"key1": "value1",
"key2": None,
"key3": 42,
"key4": None,
"key5": "another_value"
}
# The omit_token is what we want to filter out
omit_token = None
ARGS = {
"d": d,
"omit_token": omit_token
}
- 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
|
| subprocess_run |
Ran ran; our contract draft was wrong, not the code |
plasma-umass/coverup/src/coverup/utils.py code served (permissive licence) · get_code("a6bcfa534306ab26") 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 coroutine. 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 typing as T
import subprocess
import asyncio
# This function runs async subprocess commands
# We need to provide valid arguments
ARGS = {
"args": ["echo", "hello world"],
"check": False,
"timeout": None,
}
- 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 coroutine — a coroutine output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a coroutine 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
|
| test_file_path |
Ran ran; our contract draft was wrong, not the code |
plasma-umass/coverup/src/coverup/coverup.py code served (permissive licence) · get_code("28aa58f0339c64af") 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 PosixPath. 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.
from pathlib import Path
class Args:
def __init__(self):
self.tests_dir = Path("/tmp/tests")
self.prefix = "example"
ARGS = {
"args": Args(),
"test_seq": 42
}
- 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 PosixPath — a PosixPath output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a PosixPath 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
|
| token_rate_limit_for_model |
Ran ran on a synthesized input |
plasma-umass/coverup/src/coverup/llm.py code served (permissive licence) · get_code("f840bd6712a9a03f") 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 int; 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 typing as T
import warnings
MODEL_RATE_LIMITS = {'gpt-3.5-turbo': {'token': (50000000, 60), 'request': (10000, 60)}, 'gpt-3.5-turbo-0125': {'token': (50000000, 60), 'request': (10000, 60)}, 'gpt-3.5-turbo-1106': {'token': (50000000, 60), 'request': (10000, 60)}, 'gpt-3.5-turbo-16k': {'token': (50000000, 60), 'request': (10000, 60)}, 'gpt-3.5-turbo-instruct': {'token': (90000, 60), 'request': (3500, 60)}, 'gpt-3.5-turbo-instruct-0914': {'token': (90000, 60), 'request': (3500, 60)}, 'gpt-4': {'token': (1000000, 60), 'request': (10000, 60)}, 'gpt-4-0314': {'token': (1000000, 60), 'request': (10000, 60)}, 'gpt-4-0613': {'token': (1000000, 60), 'request': (10000, 60)}, 'gpt-4-32k-0314': {'token': (150000, 60), 'request': (1000, 60)}, 'gpt-4-turbo': {'token': (2000000, 60), 'request': (10000, 60)}, 'gpt-4-turbo-2024-04-09': {'token': (2000000, 60), 'request': (10000, 60)}, 'gpt-4-turbo-preview': {'token': (2000000, 60), 'request': (10000, 60)}, 'gpt-4-0125-preview': {'token': (2000000, 60), 'request': (10000, 60)}, 'gpt-4-1106-preview': {'token': (2000000, 60), 'request': (10000, 60)}, 'gpt-4o': {'token': (30000000, 60), 'request': (10000, 60)}, 'gpt-4o-2024-05-13': {'token': (30000000, 60), 'request': (10000, 60)}, 'gpt-4o-2024-08-06': {'token': (30000000, 60), 'request': (10000, 60)}, 'gpt-4o-mini': {'token': (150000000, 60), 'request': (30000, 60)}, 'gpt-4o-mini-2024-07-18': {'token': (150000000, 60), 'request': (30000, 60)}, 'bedrock/anthropic.claude-3-haiku-20240307-v1:0': {'token': (1000000, 60), 'request': (10000, 60)}, 'bedrock/anthropic.claude-3-sonnet-20240229-v1:0': {'token': (1000000, 60), 'request': (10000, 60)}, 'bedrock/anthropic.claude-3-opus-20240229-v1:0': {'token': (1000000, 60), 'request': (10000, 60)}, 'anthropic.claude-3-5-sonnet-20241022-v2:0': {'token': (400000, 50), 'request': (10000, 50)}, 'us.anthropic.claude-3-5-sonnet-20241022-v2:0': {'token': (400000, 50), 'request': (10000, 50)}, 'us.anthropic.claude-3-7-sonnet-20250219-v1:0': {'token': (400000, 50), 'request': (10000, 50)}}
def token_rate_limit_for_model(model_name: str) -> T.Tuple[int, int] | None:
if model_name.startswith('openai/'):
model_name = model_name[7:]
if (model_limits := MODEL_RATE_LIMITS.get(model_name)):
limit = model_limits.get('token')
if not 'anthropic' in model_name:
try:
import tiktoken
tiktoken.encoding_for_model(model_name)
except KeyError:
warnings.warn(f'Unable to get encoding for {model_name}; will ignore rate limit')
return None
return limit
return None
ARGS = {
'model_name': 'gpt-4o-mini'
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- tiktoken — 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 int — 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
|
| compute_cost |
Not yet run unverified (harvested, no recorded run) |
plasma-umass/coverup/src/coverup/llm.py code served (permissive licence) · get_code("def8599068e3dbf6") How it ran |
| get_info |
Not yet run unverified (harvested, no recorded run) |
plasma-umass/coverup/src/coverup/codeinfo.py code served (permissive licence) · get_code("9b6d481e57689ee5") How it ran |
| get_missing_coverage |
Not yet run unverified (harvested, no recorded run) |
plasma-umass/coverup/src/coverup/segment.py code served (permissive licence) · get_code("cc43dbef7115b69c") How it ran |
| new_test_file |
Not yet run unverified (harvested, no recorded run) |
plasma-umass/coverup/src/coverup/coverup.py code served (permissive licence) · get_code("d3e7c47f194e80d7") How it ran |
| parse_log |
Not yet run unverified (harvested, no recorded run) |
plasma-umass/coverup/src/coverup/logreader.py code served (permissive licence) · get_code("f5192e3a7fcb2025") How it ran |