async def test_json_label(self):
await Merge.cli(
"dest=json",
"src=json",
"-source-dest-filename",
self.temp_filename,
"-source-dest-label",
"somelabel",
"-source-src-filename",
self.temp_filename,
)
# Check the unlabeled source
with self.subTest(labeled=None):
async with JSONSource(
FileSourceConfig(filename=self.temp_filename)) as source:
async with source() as sctx:
repos = [repo async for repo in sctx.repos()]
self.assertEqual(len(repos), len(self.repos))
# Check the labeled source
with self.subTest(labeled="somelabel"):
async with JSONSource(
FileSourceConfig(filename=self.temp_filename,
label="somelabel")) as source:
async with source() as sctx:
repos = [repo async for repo in sctx.repos()]
self.assertEqual(len(repos), len(self.repos))
async def test_json_tag(self):
await Merge.cli(
"src=json",
"dest=json",
"-source-src-filename",
self.temp_filename,
"-source-dest-filename",
self.temp_filename,
"-source-dest-tag",
"sometag",
"-source-src-allowempty",
"-source-dest-allowempty",
"-source-src-readwrite",
"-source-dest-readwrite",
)
# Check the untagged source
with self.subTest(tagged=None):
async with JSONSource(
FileSourceConfig(filename=self.temp_filename)) as source:
async with source() as sctx:
records = [record async for record in sctx.records()]
self.assertEqual(len(records), len(self.records))
# Check the tagged source
with self.subTest(tagged="sometag"):
async with JSONSource(
FileSourceConfig(filename=self.temp_filename,
tag="sometag")) as source:
async with source() as sctx:
records = [record async for record in sctx.records()]
self.assertEqual(len(records), len(self.records))
async def test_sources(self):
with tempfile.TemporaryDirectory() as tempdir:
# Source the HTTP API will pre-load
source = JSONSource(
filename=str(pathlib.Path(tempdir, "source.json")),
allowempty=True,
readwrite=True,
)
# Record the source will have in it
myrecord = Record("myrecord", data={"features": {"f1": 0}})
await save(source, myrecord)
async with ServerRunner.patch(HTTPService.server) as tserver:
cli = await tserver.start(
HTTPService.server.cli(
"-insecure",
"-port",
"0",
"-sources",
"mysource=json",
"-source-mysource-filename",
source.config.filename,
)
)
async with self.get(
cli, "/source/mysource/record/myrecord"
) as r:
self.assertEqual(await r.json(), myrecord.export())
async def setUp(self):
await super().setUp()
self.repos = [Repo(str(random.random())) for _ in range(0, 10)]
self.temp_filename = self.mktempfile()
self.sconfig = FileSourceConfig(filename=self.temp_filename)
async with JSONSource(self.sconfig) as source:
async with source() as sctx:
for repo in self.repos:
await sctx.update(repo)
contents = json.loads(Path(self.sconfig.filename).read_text())
# Ensure there are repos in the file
self.assertEqual(
len(contents.get(self.sconfig.label)),
len(self.repos),
"ReposTestCase JSON file erroneously initialized as empty",
)
# TODO(p3) For some reason patching Model.load doesn't work
# self._stack.enter_context(patch("dffml.model.model.Model.load",
# new=model_load))
self._stack.enter_context(
patch.object(
ModelCMD,
"arg_model",
new=ModelCMD.arg_model.modify(type=model_load),
))
self._stack.enter_context(
patch("dffml.feature.feature.Feature.load", new=feature_load))
self._stack.enter_context(
patch("dffml.df.base.OperationImplementation.load",
new=opimp_load))
self._stack.enter_context(
patch("dffml.df.types.Operation.load", new=op_load))
async def setUp(self):
await super().setUp()
self.records = [Record(str(random.random())) for _ in range(0, 10)]
self.temp_filename = self.mktempfile()
self.sconfig = FileSourceConfig(filename=self.temp_filename,
readwrite=True,
allowempty=True)
async with JSONSource(self.sconfig) as source:
async with source() as sctx:
for record in self.records:
await sctx.update(record)
contents = json.loads(Path(self.sconfig.filename).read_text())
# Ensure there are records in the file
self.assertEqual(
len(contents.get(self.sconfig.tag)),
len(self.records),
"RecordsTestCase JSON file erroneously initialized as empty",
)
# TODO(p3) For some reason patching Model.load doesn't work
self._stack.enter_context(
patch("dffml.model.model.Model.load", new=model_load))
self._stack.enter_context(
patch("dffml.df.base.OperationImplementation.load",
new=opimp_load))
self._stack.enter_context(
patch("dffml.df.types.Operation.load", new=op_load))
async def setUp(self):
super().setUp()
self.repos = [Repo(str(random.random())) for _ in range(0, 10)]
self.__temp_filename = non_existant_tempfile()
self.temp_filename = self.__temp_filename.__enter__()
self.sconfig = FileSourceConfig(filename=self.temp_filename)
async with JSONSource(self.sconfig) as source:
async with source() as sctx:
for repo in self.repos:
await sctx.update(repo)
async def test_run(self):
self.repo_keys = {"add 40 and 2": 42, "multiply 42 and 10": 420}
self.repos = list(map(Repo, self.repo_keys.keys()))
os.unlink(self.temp_filename)
async with JSONSource(self.sconfig) as source:
async with source() as sctx:
for repo in self.repos:
await sctx.update(repo)
with patch.object(
OperationImplementation, "load", opimp_load
), patch.object(
Operation, "load", op_load
), tempfile.NamedTemporaryFile(
suffix=".json"
) as dataflow_file:
dataflow = io.StringIO()
with contextlib.redirect_stdout(dataflow):
await Dataflow.cli(
"create",
"-config",
"json",
*map(lambda op: op.name, OPERATIONS),
)
dataflow_file.write(dataflow.getvalue().encode())
dataflow_file.seek(0)
results = await Dataflow.cli(
"run",
"repos",
"all",
"-dataflow",
dataflow_file.name,
"primary=json",
"-sources",
"primary=json",
"-source-filename",
self.temp_filename,
"-repo-def",
"calc_string",
"-inputs",
'["result"]=get_single_spec',
)
results = {
result.src_url: result.feature("result") for result in results
}
for repo in self.repos:
self.assertIn(repo.src_url, results)
self.assertEqual(
self.repo_keys[repo.src_url], results[repo.src_url]
)
async def test_run(self):
self.record_keys = {"add 40 and 2": 42, "multiply 42 and 10": 420}
self.records = list(map(Record, self.record_keys.keys()))
os.unlink(self.temp_filename)
async with JSONSource(self.sconfig) as source:
async with source() as sctx:
for record in self.records:
await sctx.update(record)
tmpdir = tempfile.mkdtemp()
handle, dataflow_file = tempfile.mkstemp(suffix=".json", dir=tmpdir)
os.close(handle)
with open(dataflow_file, mode="w+b") as dataflow_file:
dataflow = io.StringIO()
with contextlib.redirect_stdout(dataflow):
await Dataflow.cli(
"create",
"-configloader",
"json",
*map(lambda op: op.name, OPERATIONS),
)
dataflow_file.write(dataflow.getvalue().encode())
dataflow_file.seek(0)
results = await Dataflow.cli(
"run",
"records",
"all",
"-dataflow",
dataflow_file.name,
"primary=json",
"-sources",
"primary=json",
"-source-filename",
self.temp_filename,
"-record-def",
"calc_string",
"-inputs",
'["result"]=get_single_spec',
)
results = {
result.key: result.feature("result")
for result in results
}
for record in self.records:
self.assertIn(record.key, results)
self.assertEqual(self.record_keys[record.key],
results[record.key])
shutil.rmtree(tmpdir)
async def setUp(self):
super().setUp()
self.repos = [Repo(str(random.random())) for _ in range(0, 10)]
self.__stack = ExitStack()
self._stack = self.__stack.__enter__()
self.temp_filename = self.mktempfile()
self.sconfig = FileSourceConfig(filename=self.temp_filename)
async with JSONSource(self.sconfig) as source:
async with source() as sctx:
for repo in self.repos:
await sctx.update(repo)
contents = json.loads(Path(self.sconfig.filename).read_text())
# Ensure there are repos in the file
self.assertEqual(
len(contents.get(self.sconfig.label)),
len(self.repos),
"ReposTestCase JSON file erroneously initialized as empty",
)
async def test_run(self):
test_key = "multiply 42 and 10"
self.repo_keys = {"add 40 and 2": 42, "multiply 42 and 10": 420}
self.repos = list(map(Repo, self.repo_keys.keys()))
os.unlink(self.temp_filename)
async with JSONSource(self.sconfig) as source:
async with source() as sctx:
for repo in self.repos:
await sctx.update(repo)
with tempfile.NamedTemporaryFile(suffix=".json") as dataflow_file:
dataflow = io.StringIO()
with contextlib.redirect_stdout(dataflow):
await Dataflow.cli(
"create",
"-config",
"json",
*map(lambda op: op.name, OPERATIONS),
)
dataflow_file.write(dataflow.getvalue().encode())
dataflow_file.seek(0)
results = await Dataflow.cli(
"run",
"repos",
"set",
"-keys",
test_key,
"-dataflow",
dataflow_file.name,
"primary=json",
"-sources",
"primary=json",
"-source-filename",
self.temp_filename,
"-repo-def",
"calc_string",
"-inputs",
'["result"]=get_single_spec',
)
self.assertEqual(len(results), 1)
self.assertEqual(
self.repo_keys[test_key], results[0].feature("result")
)
async def test_run(self):
self.repo_keys = {"add 40 and 2": 42, "multiply 42 and 10": 420}
self.repos = list(map(Repo, self.repo_keys.keys()))
os.unlink(self.temp_filename)
async with JSONSource(self.sconfig) as source:
async with source() as sctx:
for repo in self.repos:
await sctx.update(repo)
with patch.object(
OperationImplementation, "load", opimp_load
), patch.object(Operation, "load", op_load):
results = await OperationsAll.cli(
"-sources",
"primary=json",
"-source-filename",
self.temp_filename,
"-repo-def",
"calc_string",
"-remap",
"get_single.result=string_calculator",
"-output-specs",
'["result"]=get_single_spec',
"-dff-memory-operation-network-ops",
*map(lambda op: op.name, OPERATIONS),
"-dff-memory-opimp-network-opimps",
*map(lambda imp: imp.op.name, OPIMPS),
)
results = {
result.src_url: result.features(["string_calculator"])[
"string_calculator"
]
for result in results
}
for repo in self.repos:
self.assertIn(repo.src_url, results)
self.assertEqual(
self.repo_keys[repo.src_url], results[repo.src_url]
)
async def setUpSource(self):
return JSONSource(FileSourceConfig(filename=self.testfile))
async def test_scorer(self):
with tempfile.TemporaryDirectory() as tempdir:
model = SLRModel(
features=Features(Feature("f1", float, 1)),
predict=Feature("ans", int, 1),
location=tempdir,
)
# y = m * x + b for equation SLR is solving for
m = 5
b = 3
# Train the model
await train(model, *[{
"f1": x,
"ans": m * x + b
} for x in range(0, 10)])
source = JSONSource(
filename=pathlib.Path(tempdir, "source.json"),
allowempty=True,
readwrite=True,
)
# Record the source will have in it
await save(
source,
*[
Record(
str(i),
data={"features": {
"f1": x,
"ans": (m * x) + b
}},
) for i, x in enumerate(range(10, 20))
],
)
async with ServerRunner.patch(HTTPService.server) as tserver:
cli = await tserver.start(
HTTPService.server.cli(
"-insecure",
"-port",
"0",
"-models",
"mymodel=slr",
"-model-mymodel-location",
tempdir,
"-model-mymodel-features",
"f1:float:1",
"-model-mymodel-predict",
"ans:int:1",
"-features",
"ans:int:1",
"-sources",
"mysource=json",
"-source-mysource-filename",
str(source.config.filename),
"-scorers",
"myscorer=mse",
))
async with self.post(cli,
"/scorer/myscorer/mymodel/score",
json=["mysource"]) as r:
self.assertEqual(await r.json(), {"accuracy": 0.0})
async def setUpSource(self):
return JSONSource(
JSONSourceConfig(
filename=self.testfile, allowempty=True, readwrite=True
)
)
