def test_floating_point():
compound = mo.Compound(name='foo', mono_isotopic_molecular_weight=1.0)
mo.store(compound)
compound.mono_isotopic_molecular_weight = 1.000007
mo.store(compound)
test = mo.retrieve('compound', name='foo')[-1]
assert test.mono_isotopic_molecular_weight == 1.000007, test.mono_isotopic_molecular_weight
def save_atlas_as(sender):
n = grid.get_selected_rows()
m = grid2.get_selected_rows()
if len(m) == 0 or len(n) == 0 or len(save_atlas_as_txt.value) == 0:
ok_to_save_atlas = False
else:
ok_to_save_atlas = True
m = m[0]
n = n[0]
if ok_to_save_atlas:
kwargs = dict()
kwargs['atlas'] = grid.df.loc[n]['Atlas']
kwargs['compound'] = grid2.df.loc[m]['Compound']
kwargs['rt_min'] = rtmin_widget.value
kwargs['rt_max'] = rtmax_widget.value
kwargs['rt_peak'] = rtpeak_widget.value
atlas = mod_atlas_compound_RT_values(**kwargs)
if len(save_atlas_as_txt.value) > 1:
atlas.name = save_atlas_as_txt.value
metob.store(atlas)
else:
print("cannot save atlas")
def test_floating_point():
compound = mo.Compound(name='foo', mono_isotopic_molecular_weight=1.0)
mo.store(compound)
compound.mono_isotopic_molecular_weight = 1.000007
mo.store(compound)
test = mo.retrieve('compound', name='foo')[-1]
assert test.mono_isotopic_molecular_weight == 1.000007, test.mono_isotopic_molecular_weight
def test_store_all():
items = []
for klass in mo.WORKSPACE.subclass_lut.values():
items.append(klass())
mo.store(items)
for klass in mo.WORKSPACE.subclass_lut.values():
name = klass.__name__
assert len(mo.retrieve(name))
def test_store_all():
items = []
for klass in mo.WORKSPACE.subclass_lut.values():
items.append(klass())
mo.store(items)
for klass in mo.WORKSPACE.subclass_lut.values():
name = klass.__name__
assert len(mo.retrieve(name))
def test_nested():
test = mo.Group(items=[mo.Group(items=[mo.LcmsRun()]), mo.LcmsRun()])
assert len(test.items) == 2
test.items[1].name = 'hello'
orig_sub_version = test.items[1].unique_id
assert len(test.items) == 2
mo.store(test)
assert test.items[1].unique_id == orig_sub_version
def test_get_latest():
test = mo.Compound(name='hello')
mo.store(test)
test.name = 'goodbye'
mo.store(test)
test = mo.retrieve('compound', creation_time=test.creation_time)
assert len(test) == 1, len(test)
assert test[0].name == 'goodbye'
def test_retrieve_head():
test = mo.LcmsRun(name='foo')
mo.store(test)
old = len(mo.retrieve('lcmsrun', name='foo'))
test.description = 'bar'
mo.store(test)
new = len(mo.retrieve('lcmsrun', name='foo'))
assert new == old
def test_retrieve_head():
test = mo.LcmsRun(name='foo')
mo.store(test)
old = len(mo.retrieve('lcmsrun', name='foo'))
test.description = 'bar'
mo.store(test)
new = len(mo.retrieve('lcmsrun', name='foo'))
assert new == old
def test_get_latest():
test = mo.Compound(name='hello')
mo.store(test)
test.name = 'goodbye'
mo.store(test)
test = mo.retrieve('compound', creation_time=test.creation_time)
assert len(test) == 1, len(test)
assert test[0].name == 'goodbye'
def test_nested():
test = mo.Group(items=[mo.Group(items=[mo.LcmsRun()]), mo.LcmsRun()])
assert len(test.items) == 2
test.items[1].name = 'hello'
orig_sub_version = test.items[1].unique_id
assert len(test.items) == 2
mo.store(test)
assert test.items[1].unique_id == orig_sub_version
def test_simple_query():
test1 = mo.LcmsRun(name='First')
first_version = test1.unique_id
test1.description = "Hey there"
mo.store(test1)
assert test1.unique_id == first_version
items = mo.retrieve('lcmsrun', name='First')
assert items[-1].unique_id == test1.unique_id
assert all([i.unique_id != first_version for i in items[:-1]])
def test_simple_query():
test1 = mo.LcmsRun(name='First')
first_version = test1.unique_id
test1.description = "Hey there"
mo.store(test1)
assert test1.unique_id == first_version
items = mo.retrieve('lcmsrun', name='First')
assert items[-1].unique_id == test1.unique_id
assert all([i.unique_id != first_version for i in items[:-1]])
def test_simple():
test = mo.Group()
uid = test.unique_id
mo.store(test)
assert test.unique_id == uid
assert test.prev_uid != ''
test.name = 'hello'
mo.store(test)
assert test.unique_id == uid
assert test.prev_uid != ''
def test_unique_links():
test = mo.Group(items=[mo.Group(items=[mo.LcmsRun()]), mo.LcmsRun()])
sub_version = test.items[1].unique_id
test.items = [test.items[1]]
mo.store(test)
test.items = []
test = mo.retrieve('group', unique_id=test.unique_id)[0]
assert len(test.items) == 1, len(test.items)
assert test.items[0].unique_id == sub_version
def test_simple():
test = mo.Group()
uid = test.unique_id
mo.store(test)
assert test.unique_id == uid
assert test.prev_uid != ''
test.name = 'hello'
mo.store(test)
assert test.unique_id == uid
assert test.prev_uid != ''
def test_unique_links():
test = mo.Group(items=[mo.Group(items=[mo.LcmsRun()]), mo.LcmsRun()])
sub_version = test.items[1].unique_id
test.items = [test.items[1]]
mo.store(test)
test.items = []
test = mo.retrieve('group', unique_id=test.unique_id)[0]
assert len(test.items) == 1, len(test.items)
assert test.items[0].unique_id == sub_version
def test_preserve_provenance():
test = mo.Group(items=[mo.Group(items=[mo.LcmsRun()]), mo.LcmsRun()])
test2 = mo.Group(items=[mo.Group(items=[mo.LcmsRun()]), mo.LcmsRun()])
mo.store([test, test2])
assert len(test.items) == 2
test.items = []
test2.items = []
mo.store([test, test2])
assert len(test.items) == 0
previous = mo.retrieve('group', unique_id=test.prev_uid)[0]
assert len(previous.items) == 2, repr(previous)
def test_glob_query():
test1 = mo.LcmsRun(name='First')
test2 = mo.LcmsRun(name='Second')
test3 = mo.LcmsRun(name='Third')
mo.store([test1, test2, test3])
items = mo.retrieve('lcmsrun', name='Fir%')
assert items[-1].unique_id == test1.unique_id
items = mo.retrieve('lcmsrun', name='%econd')
assert items[-1].unique_id == test2.unique_id
items = mo.retrieve('LcmsRuns', name='T%ir%')
assert items[-1].unique_id == test3.unique_id
def test_circular_reference():
test = mo.Group(items=[mo.Group(items=[mo.LcmsRun()]), mo.LcmsRun()])
orig_id = test.unique_id
test.items[0].items.append(test)
mo.store(test)
test.items = []
test = mo.retrieve('group', unique_id=test.unique_id)[0]
sub0 = test.items[0]
assert len(sub0.items) == 2, sub0.items
assert sub0.items[1].unique_id == orig_id
assert test.unique_id == orig_id
def test_glob_query():
test1 = mo.LcmsRun(name='First')
test2 = mo.LcmsRun(name='Second')
test3 = mo.LcmsRun(name='Third')
mo.store([test1, test2, test3])
items = mo.retrieve('lcmsrun', name='Fir%')
assert items[-1].unique_id == test1.unique_id
items = mo.retrieve('lcmsrun', name='%econd')
assert items[-1].unique_id == test2.unique_id
items = mo.retrieve('LcmsRuns', name='T%ir%')
assert items[-1].unique_id == test3.unique_id
def test_circular_reference():
test = mo.Group(items=[mo.Group(items=[mo.LcmsRun()]), mo.LcmsRun()])
orig_id = test.unique_id
test.items[0].items.append(test)
mo.store(test)
test.items = []
test = mo.retrieve('group', unique_id=test.unique_id)[0]
sub0 = test.items[0]
assert len(sub0.items) == 2, sub0.items
assert sub0.items[1].unique_id == orig_id
assert test.unique_id == orig_id
def test_remove_objects():
group = mo.Group(name='foo',
items=[mo.Group(name='baz', description='hello')])
sub_id = group.items[0].unique_id
mo.store(group)
db = mo.retrieve('groups', unique_id=sub_id)[0]
assert db.unique_id == sub_id
mo.remove_objects(group, _override=True)
test = mo.retrieve('groups', name='foo')
assert not test
test_sub = mo.retrieve('groups_items', target_id=sub_id)
assert not test_sub
def test_remove_objects():
compound = mo.Compound(name='foo', MonoIsotopic_molecular_weight=1.0,
reference_xrefs=[mo.ReferenceDatabase(name='baz')])
sub_id = compound.reference_xrefs[0].unique_id
mo.store(compound)
db = mo.retrieve('referencedatabase', unique_id=sub_id)[0]
assert db.unique_id == sub_id
mo.remove_objects(compound, _override=True)
test = mo.retrieve('compound', name='foo')
assert not test
test_sub = mo.retrieve('compounds_reference_xrefs', target_id=sub_id)
assert not test_sub
def test_preserve_provenance():
test = mo.Group(items=[mo.Group(items=[mo.LcmsRun()]), mo.LcmsRun()])
test2 = mo.Group(items=[mo.Group(items=[mo.LcmsRun()]), mo.LcmsRun()])
mo.store([test, test2])
assert len(test.items) == 2
test.items = []
test2.items = []
mo.store([test, test2])
assert len(test.items) == 0
print(test.unique_id)
previous = mo.retrieve('group', unique_id=test.prev_uid)[0]
assert len(previous.items) == 2, repr(previous)
def test_remove_objects():
compound = mo.Compound(name='foo',
MonoIsotopic_molecular_weight=1.0,
reference_xrefs=[mo.ReferenceDatabase(name='baz')])
sub_id = compound.reference_xrefs[0].unique_id
mo.store(compound)
db = mo.retrieve('referencedatabase', unique_id=sub_id)[0]
assert db.unique_id == sub_id
mo.remove_objects(compound, _override=True)
test = mo.retrieve('compound', name='foo')
assert not test
test_sub = mo.retrieve('compounds_reference_xrefs', target_id=sub_id)
assert not test_sub
def test_recover():
test = mo.Group(items=[mo.Group(items=[mo.LcmsRun()]), mo.LcmsRun()])
test.name = 'howdy'
top_version = test.unique_id
sub_version = test.items[1].unique_id
mo.store(test)
mo.store(test) # should have no effect
assert len(test.items) == 2
assert test.unique_id == top_version
# make sure we can recover the previous version
test.items = []
assert test.unique_id == top_version
test = mo.retrieve('group', unique_id=top_version)[0]
assert test.unique_id == top_version
assert len(test.items) == 2, len(test.items)
assert test.unique_id == top_version
assert test.items[1].unique_id == sub_version
def test_recover():
test = mo.Group(items=[mo.Group(items=[mo.LcmsRun()]), mo.LcmsRun()])
test.name = 'howdy'
top_version = test.unique_id
sub_version = test.items[1].unique_id
mo.store(test)
mo.store(test) # should have no effect
assert len(test.items) == 2
assert test.unique_id == top_version
# make sure we can recover the previous version
test.items = []
assert test.unique_id == top_version
test = mo.retrieve('group', unique_id=top_version)[0]
assert test.unique_id == top_version
assert len(test.items) == 2, len(test.items)
assert test.unique_id == top_version
assert test.items[1].unique_id == sub_version
def test_user_preserve():
run = mo.LcmsRun(username='******')
test = mo.Reference(name='hello', username='******', lcms_run=run)
orig_id = test.unique_id
mo.store(test, _override=True)
assert test.unique_id == orig_id
mo.store(test)
assert test.unique_id != orig_id
items = mo.retrieve('reference', username='******', name='hello')
username = getpass.getuser()
assert items[-2].username == 'foo'
assert items[-1].username == username
assert items[-2].lcms_run.username == 'foo'
assert items[-1].lcms_run.username == 'foo'
run.name = 'hello'
mo.store(test)
items = mo.retrieve('reference', username='******',
creation_time=test.creation_time)
return
assert items[0].lcms_run.username == 'foo'
assert items[1].lcms_run.username == username
def test_user_preserve():
run = mo.LcmsRun(username='******')
test = mo.Reference(name='hello', username='******', lcms_run=run)
orig_id = test.unique_id
mo.store(test, _override=True)
assert test.unique_id == orig_id
mo.store(test)
assert test.unique_id != orig_id
items = mo.retrieve('reference', username='******', name='hello')
username = getpass.getuser()
assert items[-2].username == 'foo'
assert items[-1].username == username
assert items[-2].lcms_run.username == 'foo'
assert items[-1].lcms_run.username == 'foo'
run.name = 'hello'
mo.store(test)
items = mo.retrieve('reference',
username='******',
creation_time=test.creation_time)
return
assert items[0].lcms_run.username == 'foo'
assert items[1].lcms_run.username == username
def test_escape_glob():
test1 = mo.LcmsRun(description='Flow %')
mo.store(test1)
items = mo.retrieve('lcmsrun', description='Flow %%')
assert items[-1].unique_id == test1.unique_id
def test_id_grade_trait():
e = mo.IdentificationGrade(name='E')
mo.store(e)
cid = mo.CompoundIdentification(identification_grade='e')
assert cid.identification_grade.unique_id == e.unique_id
def test_store_stubs():
test = mo.Group(items=[mo.Group(items=[mo.LcmsRun()]), mo.LcmsRun()])
mo.store(test)
test = mo.retrieve('group', unique_id=test.unique_id)[0]
assert isinstance(test.items[0], mo.Group)
mo.store(test)
def test_stub_instance():
run = mo.LcmsRun(username='******')
test = mo.Reference(name='hello', lcms_run=run)
mo.store(test)
item = mo.retrieve('reference', name='hello')[0]
assert isinstance(item.lcms_run, mo.LcmsRun)
def test_stub_instance():
run = mo.LcmsRun(username='******')
test = mo.Reference(name='hello', lcms_run=run)
mo.store(test)
item = mo.retrieve('reference', name='hello')[0]
assert isinstance(item.lcms_run, mo.LcmsRun)
def test_store_stubs():
test = mo.Group(items=[mo.Group(items=[mo.LcmsRun()]), mo.LcmsRun()])
mo.store(test)
test = mo.retrieve('group', unique_id=test.unique_id)[0]
assert isinstance(test.items[0], mo.Group)
mo.store(test)
def test_id_grade_trait():
e = mo.IdentificationGrade(name='E')
mo.store(e)
cid = mo.CompoundIdentification(identification_grade='e')
assert cid.identification_grade.unique_id == e.unique_id
def test_escape_glob():
test1 = mo.LcmsRun(description='Flow %')
mo.store(test1)
items = mo.retrieve('lcmsrun', description='Flow %%')
assert items[-1].unique_id == test1.unique_id
def convert(file):
ind = file[0]
fname = file[1]
sys.stdout.write('(%s): %s\n' % (ind + 1, fname))
sys.stdout.flush()
# Get relevant information about the file.
info = patt.match(os.path.abspath(fname))
if info:
info = info.groupdict()
else:
sys.stdout.write("Invalid path name: %s\n" % fname)
sys.stdout.flush()
return
dirname = os.path.dirname(fname)
try:
username = pwd.getpwuid(os.stat(fname).st_uid).pw_name
except OSError:
try:
username = pwd.getpwuid(os.stat(dirname).st_uid).pw_name
except Exception:
username = info['username']
# Change to read only.
try:
os.chmod(fname, 0o660)
except Exception as e:
sys.stderr.write(str(e) + '\n')
sys.stderr.flush()
# Copy the original file to a pasteur backup.
if os.environ['USER'] == 'pasteur':
pasteur_path = fname.replace('raw_data', 'pasteur_backup')
dname = os.path.dirname(pasteur_path)
if not os.path.exists(dname):
os.makedirs(dname)
try:
shutil.copy(fname, pasteur_path)
except IOError as e:
if (username not in readonly_files):
readonly_files[username] = set()
readonly_files[username].add(dirname)
return
# Get a lock on the mzml file to prevent interference.
try:
fid = open(fname, 'r')
fcntl.flock(fid, fcntl.LOCK_EX | fcntl.LOCK_NB)
except IOError:
fid.close()
msg = '%s already converting in another process\n' % fname
sys.stderr.write(msg)
sys.stderr.flush()
return
# Convert to HDF and store the entry in the database.
try:
hdf5_file = fname.replace('mzML', 'h5')
sys.stderr.write('hdf5file is: %s' % hdf5_file)
#Get Acquisition Time Here
acquisition_time = get_acqtime_from_mzml(fname)
mzml_to_hdf(fname, hdf5_file, True)
os.chmod(hdf5_file, 0o660)
description = info['experiment'] + ' ' + info['path']
ctime = os.stat(fname).st_ctime
# Add this to the database unless it is already there
try:
runs = retrieve('lcmsrun', username='******', mzml_file=fname)
except Exception:
runs = list()
if not len(runs):
run = LcmsRun(name=info['path'],
description=description,
username=info['username'],
experiment=info['experiment'],
creation_time=ctime,
last_modified=ctime,
mzml_file=fname,
hdf5_file=hdf5_file,
acquisition_time=acquisition_time)
store(run)
except Exception as e:
if 'exists but it can not be written' in str(e):
if (username not in readonly_files):
readonly_files[username] = set()
readonly_files[username].add(dirname)
else:
msg = traceback.format_exception(*sys.exc_info())
msg.insert(0, 'Cannot convert %s' % fname)
dat = info['username']
if (dat not in other_errors):
other_errors[info['username']] = list()
other_errors[info['username']].append('\n'.join(msg))
sys.stderr.write(str(e) + '\n')
sys.stderr.flush()
try:
os.remove(hdf5_file)
except:
pass
finally:
fid.close()
