def test_cp_dir():
fs.rm("/tmp/labm8")
fs.rm("/tmp/labm8.copy")
fs.mkdir("/tmp/labm8/foo/bar")
assert not fs.exists("/tmp/labm8.copy")
fs.cp("/tmp/labm8/", "/tmp/labm8.copy")
assert fs.isdir("/tmp/labm8.copy")
assert fs.isdir("/tmp/labm8.copy/foo")
assert fs.isdir("/tmp/labm8.copy/foo/bar")
def test_cp_over_dir():
fs.mkdir("/tmp/labm8.tmp.src")
system.echo("Hello, world!", "/tmp/labm8.tmp.src/foo")
fs.rm("/tmp/labm8.tmp.copy")
fs.mkdir("/tmp/labm8.tmp.copy")
assert fs.isdir("/tmp/labm8.tmp.src")
assert fs.isfile("/tmp/labm8.tmp.src/foo")
assert fs.isdir("/tmp/labm8.tmp.copy")
assert not fs.isfile("/tmp/labm8.tmp.copy/foo")
fs.cp("/tmp/labm8.tmp.src", "/tmp/labm8.tmp.copy/")
assert fs.isdir("/tmp/labm8.tmp.src")
assert fs.isfile("/tmp/labm8.tmp.src/foo")
assert fs.isdir("/tmp/labm8.tmp.copy")
assert fs.isfile("/tmp/labm8.tmp.copy/foo")
assert (fs.read("/tmp/labm8.tmp.src/foo") == fs.read(
"/tmp/labm8.tmp.copy/foo"))
def get_all_sampler_datasets():
datasets = []
sampledirs = []
for versioncache in fs.ls(fs.path("~/.cache/clgen"), abspaths=True):
samplerdir = fs.path(versioncache, "sampler")
if fs.isdir(samplerdir):
sampledirs += fs.ls(samplerdir, abspaths=True)
for samplerdir in sampledirs:
inpath = fs.path(samplerdir, "kernels.db")
if fs.isfile(inpath):
datasets.append(inpath)
return datasets
def test_rmtrash():
with tempfile.NamedTemporaryFile(prefix='labm8_') as f:
assert fs.isfile(f.name)
fs.rmtrash(f.name)
assert not fs.isfile(f.name)
fs.rmtrash(f.name)
fs.rm(f.name)
with tempfile.TemporaryDirectory() as d:
fs.rm(d)
fs.mkdir(d, "foo/bar")
system.echo("Hello, world!", fs.path(d, "foo/bar/baz"))
assert fs.isfile(f, "foo/bar/baz")
fs.rmtrash(d)
assert not fs.isfile(d, "foo/bar/baz")
assert not fs.isdir(d)
def archive(*components):
"""
Returns a text archive, unpacking if necessary.
Arguments:
*components (str): Relative path.
Returns:
str: Path to archive.
"""
path = data_path(*components, exists=False)
if not fs.isdir(path):
tar.unpack_archive(path + ".tar.bz2")
return path
def __init__(self, *args, **kwargs):
"""
Construct a SkelCL server.
"""
# Fail if we can't find the path
if not fs.isdir(self.LLVM_PATH):
io.fatal("Could not find llvm path '{0}'".format(self.LLVM_PATH))
super(Server, self).__init__(*args, **kwargs)
io.info("Registered server %s/SkelCLServer ..." % SESSION_NAME)
# Setup persistent database.
self.db = migrate(Database())
self.db.status_report()
# Create an in-memory sample strategy cache.
self.strategies = cache.TransientCache()
#!/usr/bin/env python3.6
import sys
from phd.lib.labm8 import crypto
from phd.lib.labm8 import fs
from progressbar import ProgressBar
if __name__ == "__main__":
inpath = sys.argv[1]
outdir = sys.argv[2]
print(f"reading from {inpath} into {outdir}")
assert fs.isfile(inpath)
assert not fs.exists(outdir) or fs.isdir(outdir)
fs.mkdir(outdir)
with open(inpath) as infile:
text = infile.read()
kernels = text.split("// ==== START SAMPLE ====")
kernels = [kernel.strip() for kernel in kernels if kernel.strip()]
print(len(kernels), "kernels")
sha1s = [crypto.sha1_str(kernel) for kernel in kernels]
for kernel, sha1 in ProgressBar()(list(zip(kernels, sha1s))):
with open(f"{outdir}/{sha1}.txt", "w") as outfile:
print(kernel, file=outfile)
def test_FSCache_init_and_empty():
c = cache.FSCache("/tmp/labm8-cache-init-and-empty")
assert fs.isdir("/tmp/labm8-cache-init-and-empty")
c.clear()
assert not fs.isdir("/tmp/labm8-cache-init-and-empty")
def test_mkopen():
fs.rm("/tmp/labm8.dir")
assert not fs.isdir("/tmp/labm8.dir/")
f = fs.mkopen("/tmp/labm8.dir/foo", "w")
assert fs.isdir("/tmp/labm8.dir/")
f.close()
def test_mkdir_exists():
fs.mkdir("/tmp/labm8.dir/")
assert fs.isdir("/tmp/labm8.dir/")
fs.mkdir("/tmp/labm8.dir/")
fs.mkdir("/tmp/labm8.dir/")
assert fs.isdir("/tmp/labm8.dir/")
def test_mkdir_parents():
assert not fs.isdir("/tmp/labm8.dir/foo/bar")
fs.mkdir("/tmp/labm8.dir/foo/bar")
assert fs.isdir("/tmp/labm8.dir/foo/bar")
def test_mkdir():
fs.rm("/tmp/labm8.dir")
assert not fs.isdir("/tmp/labm8.dir")
fs.mkdir("/tmp/labm8.dir")
assert fs.isdir("/tmp/labm8.dir")
def test_isdir():
assert not fs.isdir(__file__)
assert fs.isdir("/")
assert not fs.isdir("/not/a/real/path (I hope!)")
def _execute(statement: str, file=sys.stdout) -> None:
if not isinstance(statement, str):
raise TypeError
# parsing is case insensitive
statement = re.sub("\s+", " ", statement.strip().lower())
components = statement.split(" ")
if not statement:
return
# Parse command modifiers:
if components[0] == "debug":
statement = re.sub(r'^debug ', '', statement)
with dsmith.debug_scope():
return _execute(statement, file=file)
elif components[0] == "verbose":
components = components[1:]
statement = re.sub(r'^verbose ', '', statement)
with dsmith.verbose_scope():
return _execute(statement, file=file)
csv = ", ".join(f"'{x}'" for x in components)
logging.debug(f"parsing input [{csv}]")
# Full command parser:
if len(components) == 1 and re.match(r'(hi|hello|hey)', components[0]):
return _hello(file=file)
if len(components) == 1 and re.match(r'(exit|quit)', components[0]):
return _exit(file=file)
if len(components) == 1 and components[0] == "help":
return _help(file=file)
if len(components) == 1 and components[0] == "version":
return _version(file=file)
if len(components) == 1 and components[0] == "test":
return _test(file=file)
if components[0] == "describe":
generators_match = re.match(r'describe (?P<lang>\w+) generators$',
statement)
testbeds_match = re.match(
r'describe (?P<available>available )?(?P<lang>\w+) testbeds$',
statement)
programs_match = re.match(r'describe (?P<lang>\w+) programs$',
statement)
testcases_match = re.match(
r'describe (?P<lang>\w+) ((?P<generator>\w+) )?testcases$',
statement)
results_match = re.match(r'describe (?P<lang>\w+) results$', statement)
if generators_match:
lang = mklang(generators_match.group("lang"))
return _describe_generators(lang=lang, file=file)
elif testbeds_match:
lang = mklang(testbeds_match.group("lang"))
available_only = True if testbeds_match.group(
"available") else False
return lang.describe_testbeds(available_only=available_only,
file=file)
elif programs_match:
lang = mklang(programs_match.group("lang"))
return _describe_programs(lang=lang, file=file)
elif testcases_match:
lang = mklang(testcases_match.group("lang"))
gen = testcases_match.group("generator")
if gen:
generator = lang.mkgenerator(gen)
return _describe_testcases(lang=lang,
generator=generator,
file=file)
else:
for generator in lang.generators:
_describe_testcases(lang=lang,
generator=generator,
file=file)
return
elif results_match:
lang = mklang(results_match.group("lang"))
return lang.describe_results(file=file)
else:
raise UnrecognizedInput
if components[0] == "make":
programs_match = re.match(
r'make ((?P<up_to>up to )?(?P<number>\d+) )?(?P<lang>\w+) program(s)?( using ('
r'?P<generator>\w+))?$', statement)
testcases_match = re.match(
r'make (?P<lang>\w+) ((?P<harness>\w+):(?P<generator>\w+)? )?testcases$',
statement)
if programs_match:
number = int(programs_match.group("number") or 0) or math.inf
lang = mklang(programs_match.group("lang"))
generator = lang.mkgenerator(programs_match.group("generator"))
return _make_programs(
lang=lang,
generator=generator,
n=number,
up_to=True if programs_match.group("up_to") else False,
file=file)
elif testcases_match:
lang = mklang(testcases_match.group("lang"))
if testcases_match.group("harness"):
harness = lang.mkharness(testcases_match.group("harness"))
if testcases_match.group("generator"):
generators = [
lang.mkgenerator(testcases_match.group("generator"))
]
else:
# No generator specified, use all:
generators = list(harness.generators)
for generator in generators:
harness.make_testcases(generator)
else:
# No harness specified, use all:
for harness in lang.harnesses:
for generator in harness.generators:
harness.make_testcases(generator)
return
else:
raise UnrecognizedInput
if components[0] == "import":
match = re.match(
r'import (?P<generator>\w+) (?P<lang>\w+) program(s)? from (?P<path>.+)$',
statement)
if match:
lang = mklang(match.group("lang"))
generator = lang.mkgenerator(match.group("generator"))
path = fs.abspath(match.group("path"))
if not fs.isdir(path):
raise ValueError(f"'{path}' is not a directory")
return generator.import_from_dir(path)
else:
raise UnrecognizedInput
if components[0] == "run":
match = re.match(
r'run (?P<lang>\w+) ((?P<harness>\w+):(?P<generator>\w+)? )?testcases( on (?P<testbed>['
r'\w+-±]+))?$', statement)
if match:
lang = mklang(match.group("lang"))
if match.group("harness"):
harness = lang.mkharness(match.group("harness"))
if match.group("generator"):
generators = [lang.mkgenerator(match.group("generator"))]
else:
# No generator specified, use all:
generators = list(harness.generators)
pairs = [(harness, generator) for generator in generators]
else:
pairs = []
# No harness specified, use all:
for harness in lang.harnesses:
pairs += [(harness, generator)
for generator in harness.generators]
for harness, generator in pairs:
if match.group("testbed"):
testbeds = lang.mktestbeds(match.group("testbed"))
else:
testbeds = harness.available_testbeds()
for testbed in testbeds:
testbed.run_testcases(harness, generator)
return
else:
raise UnrecognizedInput
if components[0] == "difftest":
match = re.match(r'difftest (?P<lang>\w+) results$', statement)
lang = mklang(match.group("lang"))
return lang.difftest()
raise UnrecognizedInput
