def test_get_description(some_paramspecs):
paramspecs = some_paramspecs[2]
ds = DataSet()
assert ds.run_id == 1
desc = ds.description
assert desc == RunDescriber(InterDependencies())
ds.add_parameter(paramspecs['ps1'])
desc = ds.description
assert desc == RunDescriber(InterDependencies(paramspecs['ps1']))
ds.add_parameter(paramspecs['ps2'])
desc = ds.description
assert desc == RunDescriber(
InterDependencies(paramspecs['ps1'], paramspecs['ps2']))
# the run description gets written as the first data point is added,
# so now no description should be stored in the database
prematurely_loaded_ds = DataSet(run_id=1)
assert prematurely_loaded_ds.description == RunDescriber(
InterDependencies())
ds.add_result({'ps1': 1, 'ps2': 2})
loaded_ds = DataSet(run_id=1)
assert loaded_ds.description == desc
def test_get_description(experiment, some_paramspecs):
paramspecs = some_paramspecs[2]
ds = DataSet()
assert ds.run_id == 1
desc = ds.description
assert desc == RunDescriber(InterDependencies())
ds.add_parameter(paramspecs['ps1'])
desc = ds.description
assert desc == RunDescriber(InterDependencies(paramspecs['ps1']))
ds.add_parameter(paramspecs['ps2'])
desc = ds.description
assert desc == RunDescriber(InterDependencies(paramspecs['ps1'],
paramspecs['ps2']))
# the run description gets written as the dataset is marked as started,
# so now no description should be stored in the database
prematurely_loaded_ds = DataSet(run_id=1)
assert prematurely_loaded_ds.description == RunDescriber(InterDependencies())
ds.mark_started()
loaded_ds = DataSet(run_id=1)
assert loaded_ds.description == desc
def test_new_to_old(some_paramspecbases):
(ps1, ps2, ps3, ps4) = some_paramspecbases
idps_new = InterDependencies_(dependencies={ps1: (ps2, ps3)},
standalones=(ps4, ))
paramspec1 = ParamSpec(name=ps1.name,
paramtype=ps1.type,
label=ps1.label,
unit=ps1.unit,
depends_on=[ps2.name, ps3.name])
paramspec2 = ParamSpec(name=ps2.name,
paramtype=ps2.type,
label=ps2.label,
unit=ps2.unit)
paramspec3 = ParamSpec(name=ps3.name,
paramtype=ps3.type,
label=ps3.label,
unit=ps3.unit)
paramspec4 = ParamSpec(name=ps4.name,
paramtype=ps4.type,
label=ps4.label,
unit=ps4.unit)
idps_old_expected = InterDependencies(paramspec2, paramspec3, paramspec1,
paramspec4)
assert new_to_old(idps_new) == idps_old_expected
#
idps_new = InterDependencies_(inferences={ps1: (ps2, ps3)},
standalones=(ps4, ))
paramspec1 = ParamSpec(name=ps1.name,
paramtype=ps1.type,
label=ps1.label,
unit=ps1.unit,
inferred_from=[ps2.name, ps3.name])
paramspec2 = ParamSpec(name=ps2.name,
paramtype=ps2.type,
label=ps2.label,
unit=ps2.unit)
paramspec3 = ParamSpec(name=ps3.name,
paramtype=ps3.type,
label=ps3.label,
unit=ps3.unit)
paramspec4 = ParamSpec(name=ps4.name,
paramtype=ps4.type,
label=ps4.label,
unit=ps4.unit)
idps_old_expected = InterDependencies(paramspec2, paramspec3, paramspec1,
paramspec4)
assert new_to_old(idps_new) == idps_old_expected
def test_equality(some_paramspecs):
idp1 = InterDependencies(*some_paramspecs[1].values())
idp2 = InterDependencies(*some_paramspecs[2].values())
idp3 = InterDependencies(*some_paramspecs[1].values())
desc_1 = RunDescriber(interdeps=idp1)
desc_2 = RunDescriber(interdeps=idp2)
desc_3 = RunDescriber(interdeps=idp3)
assert desc_1 == desc_3
assert desc_1 != desc_2
assert desc_3 != desc_2
def test_old_to_new(some_paramspecs):
ps1 = some_paramspecs[1]['ps1']
ps2 = some_paramspecs[1]['ps2']
ps3 = some_paramspecs[1]['ps3']
ps4 = some_paramspecs[1]['ps4']
ps5 = some_paramspecs[1]['ps5']
ps6 = some_paramspecs[1]['ps6']
idps_old = InterDependencies(ps1, ps2, ps3)
idps_new = old_to_new(idps_old)
ps1_base = ps1.base_version()
ps2_base = ps2.base_version()
ps3_base = ps3.base_version()
ps4_base = ps4.base_version()
ps5_base = ps5.base_version()
ps6_base = ps6.base_version()
assert idps_new.dependencies == {}
assert idps_new.inferences == {ps3_base: (ps1_base, )}
assert idps_new.standalones == set((ps2_base, ))
paramspecs = (ps1_base, ps2_base, ps3_base)
assert idps_new._id_to_paramspec == {ps.name: ps for ps in paramspecs}
idps_old = InterDependencies(ps2, ps4, ps1, ps2, ps3, ps5, ps6)
idps_new = old_to_new(idps_old)
assert idps_new.dependencies == {
ps5_base: (ps3_base, ps4_base),
ps6_base: (ps3_base, ps4_base)
}
assert idps_new.inferences == {
ps3_base: (ps1_base, ),
ps4_base: (ps2_base, )
}
assert idps_new.standalones == set()
paramspecs = (ps1_base, ps2_base, ps3_base, ps4_base, ps5_base, ps6_base)
assert idps_new._id_to_paramspec == {ps.name: ps for ps in paramspecs}
idps_old = InterDependencies(ps1, ps2)
idps_new = old_to_new(idps_old)
assert idps_new.dependencies == {}
assert idps_new.inferences == {}
assert idps_new.standalones == set((ps1_base, ps2_base))
paramspecs = (ps1_base, ps2_base)
assert idps_new._id_to_paramspec == {ps.name: ps for ps in paramspecs}
def test_fix_wrong_run_descriptions():
v3fixpath = os.path.join(fixturepath, 'db_files', 'version3')
dbname_old = os.path.join(v3fixpath, 'some_runs_without_run_description.db')
if not os.path.exists(dbname_old):
pytest.skip(
"No db-file fixtures found. You can generate test db-files"
" using the scripts in the legacy_DB_generation folder")
with temporarily_copied_DB(dbname_old, debug=False, version=3) as conn:
assert get_user_version(conn) == 3
ds1 = DataSet(conn=conn, run_id=1)
expected_description = ds1.description
empty_description = RunDescriber(InterDependencies())
_fix_wrong_run_descriptions(conn, [1, 2, 3, 4])
ds2 = DataSet(conn=conn, run_id=2)
assert expected_description == ds2.description
ds3 = DataSet(conn=conn, run_id=3)
assert expected_description == ds3.description
ds4 = DataSet(conn=conn, run_id=4)
assert empty_description == ds4.description
def test_wrong_input_raises():
for pspecs in [['p1', 'p2', 'p3'],
[ParamSpec('p1', paramtype='numeric'), 'p2'],
['p1', ParamSpec('p2', paramtype='text')]]:
with pytest.raises(ValueError):
InterDependencies(pspecs)
def deserialize(cls, ser: Dict[str, Any]) -> 'RunDescriber':
"""
Make a RunDescriber object based on a serialized version of it
"""
idp = InterDependencies.deserialize(ser['interdependencies'])
rundesc = cls(interdeps=idp)
return rundesc
def test_update_runs_description(dataset):
invalid_descs = ['{}', 'description']
for idesc in invalid_descs:
with pytest.raises(ValueError):
mut.update_run_description(dataset.conn, dataset.run_id, idesc)
desc = RunDescriber(InterDependencies()).to_json()
mut.update_run_description(dataset.conn, dataset.run_id, desc)
def test_serialization_and_back(some_paramspecs):
idp = InterDependencies(*some_paramspecs[1].values())
desc = RunDescriber(interdeps=idp)
ser_desc = desc.serialize()
new_desc = RunDescriber.deserialize(ser_desc)
assert isinstance(new_desc, RunDescriber)
assert desc == new_desc
def test_serialization_as_old(some_paramspecs):
"""
Test that a RunDescriber always serializes itself as an old style
RunDescriber, even when given new style interdeps
"""
idps_old = InterDependencies(*some_paramspecs[2].values())
idps_new = old_to_new(idps_old)
new_desc = RunDescriber(idps_new)
old_desc = RunDescriber(idps_old)
assert new_desc.serialize() == old_desc.serialize()
def test_yaml_creation_and_loading(some_paramspecs):
yaml = YAML()
for group in some_paramspecs.values():
paramspecs = group.values()
idp = InterDependencies(*paramspecs)
desc = RunDescriber(interdeps=idp)
yaml_str = desc.to_yaml()
assert isinstance(yaml_str, str)
ydict = dict(yaml.load(yaml_str))
assert list(ydict.keys()) == ['interdependencies']
new_desc = RunDescriber.from_yaml(yaml_str)
assert new_desc == desc
def deserialize(cls, ser: Dict[str, Any]) -> 'RunDescriber':
"""
Make a RunDescriber object based on a serialized version of it
"""
# We must currently support new and old type InterDep.s objects
idp: Union[InterDependencies, InterDependencies_]
if 'paramspecs' in ser['interdependencies'].keys():
idp = InterDependencies.deserialize(ser['interdependencies'])
else:
idp = InterDependencies_.deserialize(ser['interdependencies'])
rundesc = cls(interdeps=idp)
return rundesc
def add_parameter(self, spec: ParamSpec):
"""
Add a parameter to the DataSet. To ensure sanity, parameters must be
added to the DataSet in a sequence matching their internal
dependencies, i.e. first independent parameters, next other
independent parameters inferred from the first ones, and finally
the dependent parameters. Note that adding parameters to the DataSet
does not reflect in the DB file until the DataSet is marked as started
"""
if not self.pristine:
raise RuntimeError('Can not add parameters to a DataSet that has '
'been started.')
if self.parameters:
old_params = self.parameters.split(',')
else:
old_params = []
if spec.name in old_params:
raise ValueError(f'Duplicate parameter name: {spec.name}')
inf_from = spec.inferred_from.split(', ')
if inf_from == ['']:
inf_from = []
for ifrm in inf_from:
if ifrm not in old_params:
raise ValueError('Can not infer parameter '
f'{spec.name} from {ifrm}, '
'no such parameter in this DataSet')
dep_on = spec.depends_on.split(', ')
if dep_on == ['']:
dep_on = []
for dp in dep_on:
if dp not in old_params:
raise ValueError('Can not have parameter '
f'{spec.name} depend on {dp}, '
'no such parameter in this DataSet')
desc = self.description
desc.interdeps = InterDependencies(*desc.interdeps.paramspecs, spec)
self._description = desc
def test_equality_old(some_paramspecs):
# TODO: make this more fancy with itertools
ps1 = some_paramspecs[1]['ps1']
ps2 = some_paramspecs[1]['ps2']
ps3 = some_paramspecs[1]['ps3']
ps4 = some_paramspecs[1]['ps4']
ps5 = some_paramspecs[1]['ps5']
ps6 = some_paramspecs[1]['ps6']
assert InterDependencies(ps1, ps2, ps3) == InterDependencies(ps3, ps2, ps1)
assert InterDependencies(ps1, ps6, ps3) == InterDependencies(ps3, ps6, ps1)
assert InterDependencies(ps4, ps5, ps3) == InterDependencies(ps3, ps4, ps5)
def test_yaml_creation_and_loading(some_paramspecs):
try:
YAML = RunDescriber._ruamel_importer()
except ImportError:
pytest.skip('No ruamel module installed, skipping test')
yaml = YAML()
for group in some_paramspecs.values():
paramspecs = group.values()
idp = InterDependencies(*paramspecs)
desc = RunDescriber(interdeps=idp)
yaml_str = desc.to_yaml()
assert isinstance(yaml_str, str)
ydict = dict(yaml.load(yaml_str))
assert list(ydict.keys()) == ['interdependencies']
new_desc = RunDescriber.from_yaml(yaml_str)
assert new_desc == desc
def add_parameter(self, spec: ParamSpec):
"""
Add a parameter to the DataSet. To ensure sanity, parameters must be
added to the DataSet in a sequence matching their internal
dependencies, i.e. first independent parameters, next other
independent parameters inferred from the first ones, and finally
the dependent parameters
"""
if self.parameters:
old_params = self.parameters.split(',')
else:
old_params = []
if spec.name in old_params:
raise ValueError(f'Duplicate parameter name: {spec.name}')
inf_from = spec.inferred_from.split(', ')
if inf_from == ['']:
inf_from = []
for ifrm in inf_from:
if ifrm not in old_params:
raise ValueError('Can not infer parameter '
f'{spec.name} from {ifrm}, '
'no such parameter in this DataSet')
dep_on = spec.depends_on.split(', ')
if dep_on == ['']:
dep_on = []
for dp in dep_on:
if dp not in old_params:
raise ValueError('Can not have parameter '
f'{spec.name} depend on {dp}, '
'no such parameter in this DataSet')
add_parameter(self.conn, self.table_name, spec)
desc = self.description
desc.interdeps = InterDependencies(*desc.interdeps.paramspecs, spec)
self._description = desc
def fix_wrong_run_descriptions(conn: ConnectionPlus,
run_ids: Sequence[int]) -> None:
"""
NB: This is a FIX function. Do not use it unless your database has been
diagnosed with the problem that this function fixes.
Overwrite faulty run_descriptions by using information from the layouts and
dependencies tables. If a correct description is found for a run, that
run is left untouched.
Args:
conn: The connection to the database
run_ids: The runs to (potentially) fix
"""
user_version = get_user_version(conn)
if not user_version == 3:
raise RuntimeError('Database of wrong version. Will not apply fix. '
'Expected version 3, found version {user_version}')
log.info('[*] Fixing run descriptions...')
for run_id in run_ids:
trusted_paramspecs = get_parameters(conn, run_id)
trusted_desc = RunDescriber(interdeps=InterDependencies(
*trusted_paramspecs))
actual_desc_str = select_one_where(conn, "runs", "run_description",
"run_id", run_id)
if actual_desc_str == trusted_desc.to_json():
log.info(f'[+] Run id: {run_id} had an OK description')
else:
log.info(f'[-] Run id: {run_id} had a broken description. '
f'Description found: {actual_desc_str}')
update_run_description(conn, run_id, trusted_desc.to_json())
log.info(f' Run id: {run_id} has been updated.')
def __init__(self,
path_to_db: str = None,
run_id: Optional[int] = None,
conn: Optional[ConnectionPlus] = None,
exp_id=None,
name: str = None,
specs: Optional[SpecsOrInterDeps] = None,
values=None,
metadata=None) -> None:
"""
Create a new DataSet object. The object can either hold a new run or
an already existing run. If a run_id is provided, then an old run is
looked up, else a new run is created.
Args:
path_to_db: path to the sqlite file on disk. If not provided, the
path will be read from the config.
run_id: provide this when loading an existing run, leave it
as None when creating a new run
conn: connection to the DB; if provided and `path_to_db` is
provided as well, then a ValueError is raised (this is to
prevent the possibility of providing a connection to a DB
file that is different from `path_to_db`)
exp_id: the id of the experiment in which to create a new run.
Ignored if run_id is provided.
name: the name of the dataset. Ignored if run_id is provided.
specs: paramspecs belonging to the dataset. Ignored if run_id is
provided.
values: values to insert into the dataset. Ignored if run_id is
provided.
metadata: metadata to insert into the dataset. Ignored if run_id
is provided.
"""
if path_to_db is not None and conn is not None:
raise ValueError("Both `path_to_db` and `conn` arguments have "
"been passed together with non-None values. "
"This is not allowed.")
self._path_to_db = path_to_db or get_DB_location()
self.conn = make_connection_plus_from(conn) if conn is not None else \
connect(self.path_to_db)
self._run_id = run_id
self._debug = False
self.subscribers: Dict[str, _Subscriber] = {}
self._interdeps: InterDependencies_
if run_id is not None:
if not run_exists(self.conn, run_id):
raise ValueError(f"Run with run_id {run_id} does not exist in "
f"the database")
self._completed = completed(self.conn, self.run_id)
run_desc = self._get_run_description_from_db()
if run_desc._old_style_deps:
# TODO: what if the old run had invalid interdep.s?
old_idps: InterDependencies = cast(InterDependencies,
run_desc.interdeps)
self._interdeps = old_to_new(old_idps)
else:
new_idps: InterDependencies_ = cast(InterDependencies_,
run_desc.interdeps)
self._interdeps = new_idps
self._metadata = get_metadata_from_run_id(self.conn, run_id)
self._started = self.run_timestamp_raw is not None
else:
# Actually perform all the side effects needed for the creation
# of a new dataset. Note that a dataset is created (in the DB)
# with no parameters; they are written to disk when the dataset
# is marked as started
if exp_id is None:
if len(get_experiments(self.conn)) > 0:
exp_id = get_last_experiment(self.conn)
else:
raise ValueError("No experiments found."
"You can start a new one with:"
" new_experiment(name, sample_name)")
name = name or "dataset"
_, run_id, __ = create_run(self.conn,
exp_id,
name,
generate_guid(),
parameters=None,
values=values,
metadata=metadata)
# this is really the UUID (an ever increasing count in the db)
self._run_id = run_id
self._completed = False
self._started = False
if isinstance(specs, InterDependencies_):
self._interdeps = specs
elif specs is not None:
self._interdeps = old_to_new(InterDependencies(*specs))
else:
self._interdeps = InterDependencies_()
self._metadata = get_metadata_from_run_id(self.conn, self.run_id)
def generate_DB_file_with_some_runs_having_not_run_descriptions():
"""
Generate a .db-file with a handful of runs some of which lack run
description or have it as empty object (based on a real case).
Generated runs:
#1: run with parameters and correct run description
#2: run with parameters but run description is NULL
#3: run with parameters but run description is empty RunDescriber
#4: run without parameters but run description is NULL
"""
v3fixturepath = os.path.join(fixturepath, 'version3')
os.makedirs(v3fixturepath, exist_ok=True)
path = os.path.join(v3fixturepath, 'some_runs_without_run_description.db')
if os.path.exists(path):
os.remove(path)
from qcodes.dataset.measurements import Measurement
from qcodes.dataset.experiment_container import Experiment
from qcodes import Parameter
from qcodes.dataset.descriptions import RunDescriber
from qcodes.dataset.dependencies import InterDependencies
exp = Experiment(path_to_db=path,
name='experiment_1',
sample_name='no_sample_1')
conn = exp.conn
# Now make some parameters to use in measurements
params = []
for n in range(5):
params.append(
Parameter(f'p{n}',
label=f'Parameter {n}',
unit=f'unit {n}',
set_cmd=None,
get_cmd=None))
# Set up a measurement
meas = Measurement(exp)
meas.register_parameter(params[0])
meas.register_parameter(params[1])
meas.register_parameter(params[2], basis=(params[0], ))
meas.register_parameter(params[3], basis=(params[1], ))
meas.register_parameter(params[4], setpoints=(params[2], params[3]))
# Initially make 3 correct runs
run_ids = []
for _ in range(3):
with meas.run() as datasaver:
for x in np.random.rand(10):
for y in np.random.rand(10):
z = np.random.rand()
datasaver.add_result((params[2], x), (params[3], y),
(params[4], z))
run_ids.append(datasaver.run_id)
assert [1, 2, 3] == run_ids, 'Run ids of generated runs are not as ' \
'expected after generating runs #1-3'
# Formulate SQL query for adjusting run_description column
set_run_description_sql = f"""
UPDATE runs
SET run_description = ?
WHERE run_id == ?
"""
# Make run_description of run #2 NULL
conn.execute(set_run_description_sql, (None, run_ids[1]))
conn.commit() # just to be sure
# Make run_description of run #3 equivalent to an empty RunDescriber
empty_run_description = RunDescriber(InterDependencies()).to_json()
conn.execute(set_run_description_sql, (empty_run_description, run_ids[2]))
conn.commit() # just to be sure
# Set up a measurement without parameters, and create run #4 out of it
meas_no_params = Measurement(exp)
with meas_no_params.run() as datasaver:
pass
run_ids.append(datasaver.run_id)
assert [1, 2, 3, 4] == run_ids, 'Run ids of generated runs are not as ' \
'expected after generating run #4'
# Make run_description of run #4 NULL
conn.execute(set_run_description_sql, (None, run_ids[3]))
conn.commit() # just to be sure
def upgrade_3_to_4(conn: ConnectionPlus) -> None:
"""
Perform the upgrade from version 3 to version 4. This really
repeats the version 3 upgrade as it originally had two bugs in
the inferred annotation. inferred_from was passed incorrectly
resulting in the parameter being marked inferred_from for each char
in the inferred_from variable and inferred_from was not handled
correctly for parameters that were neither dependencies nor dependent on
other parameters. Both have since been fixed so rerun the upgrade.
"""
no_of_runs_query = "SELECT max(run_id) FROM runs"
no_of_runs = one(atomic_transaction(conn, no_of_runs_query), 'max(run_id)')
no_of_runs = no_of_runs or 0
# If one run fails, we want the whole upgrade to roll back, hence the
# entire upgrade is one atomic transaction
with atomic(conn) as conn:
result_tables = _2to3_get_result_tables(conn)
layout_ids_all = _2to3_get_layout_ids(conn)
indeps_all = _2to3_get_indeps(conn)
deps_all = _2to3_get_deps(conn)
layouts = _2to3_get_layouts(conn)
dependencies = _2to3_get_dependencies(conn)
pbar = tqdm(range(1, no_of_runs + 1))
pbar.set_description("Upgrading database")
for run_id in pbar:
if run_id in layout_ids_all:
result_table_name = result_tables[run_id]
layout_ids = list(layout_ids_all[run_id])
if run_id in indeps_all:
independents = tuple(indeps_all[run_id])
else:
independents = ()
if run_id in deps_all:
dependents = tuple(deps_all[run_id])
else:
dependents = ()
paramspecs = _2to3_get_paramspecs(conn, layout_ids, layouts,
dependencies, dependents,
independents,
result_table_name)
interdeps = InterDependencies(*paramspecs.values())
desc = RunDescriber(interdeps=interdeps)
json_str = desc.to_json()
else:
json_str = RunDescriber(InterDependencies()).to_json()
sql = f"""
UPDATE runs
SET run_description = ?
WHERE run_id == ?
"""
cur = conn.cursor()
cur.execute(sql, (json_str, run_id))
log.debug(f"Upgrade in transition, run number {run_id}: OK")
def upgrade_2_to_3(conn: ConnectionPlus) -> None:
"""
Perform the upgrade from version 2 to version 3
Insert a new column, run_description, to the runs table and fill it out
for exisitng runs with information retrieved from the layouts and
dependencies tables represented as the to_json output of a RunDescriber
object
"""
no_of_runs_query = "SELECT max(run_id) FROM runs"
no_of_runs = one(atomic_transaction(conn, no_of_runs_query), 'max(run_id)')
no_of_runs = no_of_runs or 0
# If one run fails, we want the whole upgrade to roll back, hence the
# entire upgrade is one atomic transaction
with atomic(conn) as conn:
sql = "ALTER TABLE runs ADD COLUMN run_description TEXT"
transaction(conn, sql)
result_tables = _2to3_get_result_tables(conn)
layout_ids_all = _2to3_get_layout_ids(conn)
indeps_all = _2to3_get_indeps(conn)
deps_all = _2to3_get_deps(conn)
layouts = _2to3_get_layouts(conn)
dependencies = _2to3_get_dependencies(conn)
pbar = tqdm(range(1, no_of_runs + 1))
pbar.set_description("Upgrading database")
for run_id in pbar:
if run_id in layout_ids_all:
result_table_name = result_tables[run_id]
layout_ids = list(layout_ids_all[run_id])
if run_id in indeps_all:
independents = tuple(indeps_all[run_id])
else:
independents = ()
if run_id in deps_all:
dependents = tuple(deps_all[run_id])
else:
dependents = ()
paramspecs = _2to3_get_paramspecs(conn, layout_ids, layouts,
dependencies, dependents,
independents,
result_table_name)
interdeps = InterDependencies(*paramspecs.values())
desc = RunDescriber(interdeps=interdeps)
json_str = desc.to_json()
else:
json_str = RunDescriber(InterDependencies()).to_json()
sql = f"""
UPDATE runs
SET run_description = ?
WHERE run_id == ?
"""
cur = conn.cursor()
cur.execute(sql, (json_str, run_id))
log.debug(f"Upgrade in transition, run number {run_id}: OK")
def _insert_run(
conn: ConnectionPlus,
exp_id: int,
name: str,
guid: str,
parameters: Optional[List[ParamSpec]] = None,
):
# get run counter and formatter from experiments
run_counter, format_string = select_many_where(conn,
"experiments",
"run_counter",
"format_string",
where_column="exp_id",
where_value=exp_id)
run_counter += 1
formatted_name = format_table_name(format_string, name, exp_id,
run_counter)
table = "runs"
parameters = parameters or []
desc_str = RunDescriber(InterDependencies(*parameters)).to_json()
with atomic(conn) as conn:
if parameters:
query = f"""
INSERT INTO {table}
(name,
exp_id,
guid,
result_table_name,
result_counter,
run_timestamp,
parameters,
is_completed,
run_description)
VALUES
(?,?,?,?,?,?,?,?,?)
"""
curr = transaction(conn, query, name, exp_id, guid, formatted_name,
run_counter, None,
",".join([p.name for p in parameters]), False,
desc_str)
_add_parameters_to_layout_and_deps(conn, formatted_name,
*parameters)
else:
query = f"""
INSERT INTO {table}
(name,
exp_id,
guid,
result_table_name,
result_counter,
run_timestamp,
is_completed,
run_description)
VALUES
(?,?,?,?,?,?,?,?)
"""
curr = transaction(conn, query, name, exp_id, guid, formatted_name,
run_counter, None, False, desc_str)
run_id = curr.lastrowid
return run_counter, formatted_name, run_id
def test_serialization_dict_keys(some_paramspecs):
idp = InterDependencies(*some_paramspecs[1].values())
desc = RunDescriber(interdeps=idp)
ser_desc = desc.serialize()
assert list(ser_desc.keys()) == ['interdependencies']
def test_old_to_new_and_back(some_paramspecs):
idps_old = InterDependencies(*some_paramspecs[1].values())
idps_new = old_to_new(idps_old)
assert new_to_old(idps_new) == idps_old