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