def _make_level(self, doc, irrad, level, ids, ans):
root = doc['root']
options = doc['options']
lroot = os.path.join(root, irrad, level)
r_mkdir(lroot)
n = len(ans)
prog = self.open_progress(n, close_at_end=False)
ans = self.make_analyses(ans, progress=prog, use_cache=False)
#group by stepheat vs fusion
pred = lambda x: bool(x.step)
ans = sorted(ans, key=pred)
stepheat, fusion = map(list, partition(ans, pred))
# apred = lambda x: x.aliquot
# stepheat = sorted(stepheat, key=apred)
# if stepheat:
# self._make_editor(stepheat, 'step_heat', options, prog, ln_root, li)
project = 'J'
# lns=[li.identifier for li in level.labnumbers]
if fusion:
save_args = (lroot, level, '{} {}'.format(irrad,
level), project, ids)
self._make_editor(fusion, ('fusion', 'fusion_grouped'), options,
prog, 'aliquot', save_args)
prog.close()
def _make_level(self, doc, irrad, level,ids, ans):
root = doc['root']
options = doc['options']
lroot = os.path.join(root, irrad, level)
r_mkdir(lroot)
n=len(ans)
prog = self.open_progress(n, close_at_end=False)
ans = self.make_analyses(ans, progress=prog, use_cache=False)
#group by stepheat vs fusion
pred = lambda x: bool(x.step)
ans = sorted(ans, key=pred)
stepheat, fusion = map(list, partition(ans, pred))
# apred = lambda x: x.aliquot
# stepheat = sorted(stepheat, key=apred)
# if stepheat:
# self._make_editor(stepheat, 'step_heat', options, prog, ln_root, li)
project='J'
# lns=[li.identifier for li in level.labnumbers]
if fusion:
save_args=(lroot, level, '{} {}'.format(irrad, level),
project, ids)
self._make_editor(fusion, ('fusion','fusion_grouped'),
options, prog, 'aliquot',
save_args)
prog.close()
def _get_working_repo(self):
if not self._repo:
from git import Repo
p = self.build_repo
if not p:
self.information_dialog(
'Please set "build repo" in Updater Preferences',
position=STARTUP_MESSAGE_POSITION)
return
if not os.path.isdir(p):
r_mkdir(p)
if self.remote:
url = 'https://github.com/{}.git'.format(self.remote)
repo = Repo.clone_from(url, p)
else:
self.information_dialog(
'Please set "remote" in Updater Preferences',
position=STARTUP_MESSAGE_POSITION)
return
else:
repo = Repo(p)
self._repo = repo
return self._repo
def _make_labnumber(self, li, root, options, prog):
#make dir for labnumber
ident = li.identifier
ln_root = os.path.join(root, ident)
r_mkdir(ln_root)
prog.change_message('Making {} for {}'.format(self._tag, ident))
#filter invalid analyses
ans=filter(lambda x: not x.tag=='invalid', li.analyses)
#group by stepheat vs fusion
pred = lambda x: bool(x.step)
ans = sorted(ans, key=pred)
stepheat, fusion = map(list, partition(ans, pred))
apred = lambda x: x.aliquot
stepheat = sorted(stepheat, key=apred)
project='Minna Bluff'
li = li.identifier
if stepheat:
key=lambda x: x.aliquot
stepheat=sorted(stepheat, key=key)
for aliquot, ais in groupby(stepheat, key=key):
name=make_runid(li, aliquot, '')
self._make_editor(ais, 'step_heat', options, prog, False,
(ln_root, name, name, project, (li,)))
if fusion:
self._make_editor(fusion, 'fusion', options, prog, False,
(ln_root, li, li, project, (li,)))
def _make_labnumber(self, li, root, options, prog):
#make dir for labnumber
ident = li.identifier
ln_root = os.path.join(root, ident)
r_mkdir(ln_root)
prog.change_message('Making {} for {}'.format(self._tag, ident))
#filter invalid analyses
ans = filter(lambda x: not x.tag == 'invalid', li.analyses)
#group by stepheat vs fusion
pred = lambda x: bool(x.step)
ans = sorted(ans, key=pred)
stepheat, fusion = map(list, partition(ans, pred))
apred = lambda x: x.aliquot
stepheat = sorted(stepheat, key=apred)
project = 'Minna Bluff'
li = li.identifier
if stepheat:
key = lambda x: x.aliquot
stepheat = sorted(stepheat, key=key)
for aliquot, ais in groupby(stepheat, key=key):
name = make_runid(li, aliquot, '')
self._make_editor(ais, 'step_heat', options, prog, False,
(ln_root, name, name, project, (li, )))
if fusion:
self._make_editor(fusion, 'fusion', options, prog, False,
(ln_root, li, li, project, (li, )))
def _get_local_repo(self):
p = self._get_working_directory()
if not os.path.isdir(p):
r_mkdir(p)
repo = Repo.init(p)
else:
repo = Repo(p)
return repo
def _get_local_repo(self):
p = self._get_working_directory()
if not os.path.isdir(p):
r_mkdir(p)
repo = Repo.init(p)
else:
repo = Repo(p)
return repo
def build(self, groups, path=None, options=None):
if options is None:
options = XLSXAnalysisTableWriterOptions()
self._options = options
if path is None:
path = options.path
self.debug('saving table to {}'.format(path))
r_mkdir(os.path.dirname(path))
self._new_workbook(path)
self._bold = self._workbook.add_format({'bold': True})
self._superscript = self._workbook.add_format({'font_script': 1})
self._subscript = self._workbook.add_format({'font_script': 2})
self._ital = self._workbook.add_format({'italic': True})
unknowns = groups.get('unknowns')
if unknowns:
# make a human optimized table
unknowns = self._make_human_unknowns(unknowns)
# make a machine optimized table
munknowns = groups.get('machine_unknowns')
if munknowns:
self._make_machine_unknowns(munknowns)
airs = groups.get('airs')
if airs:
self._make_airs(airs)
blanks = groups.get('blanks')
if blanks:
self._make_blanks(blanks)
monitors = groups.get('monitors')
if monitors:
self._make_monitors(monitors)
# if not self._options.include_production_ratios:
# self._make_irradiations(unknowns)
if self._options.include_summary_sheet:
if unknowns:
self._make_summary_sheet(unknowns)
self._workbook.close()
view = self._options.auto_view
if not view:
view = confirm(None, 'Table saved to {}\n\nView Table?'.format(path)) == YES
if view:
view_file(path, application='Excel')
def build_directories():
from pychron.paths import r_mkdir, paths
root = os.path.join(os.path.expanduser('~'), 'RHM')
if not os.path.isdir(root):
os.mkdir(root)
# servers = os.path.join(root, 'servers')
ldir = os.path.join(root, 'log')
r_mkdir(ldir)
paths.log_dir = ldir
paths.root = root
def build_directories():
from pychron.paths import r_mkdir, paths
root=os.path.join(os.path.expanduser('~'), 'RHM')
if not os.path.isdir(root):
os.mkdir(root)
# servers = os.path.join(root, 'servers')
ldir = os.path.join(root, 'log')
r_mkdir(ldir)
paths.log_dir = ldir
paths.root = root
def _get_working_repo(self):
if not self._repo:
from git import Repo
p = paths.build_repo
if not os.path.isdir(p):
r_mkdir(p)
url = 'https://github.com/{}.git'.format(self.remote)
repo = Repo.clone_from(url, p)
else:
repo = Repo(p)
self._repo = repo
return self._repo
def _add_analysis(self, an, commit=True, progress=None):
root = os.path.join(self.repo_manager.root, an.sample, an.labnumber)
p = os.path.join(root, '{}.yaml'.format(an.record_id))
if not os.path.isfile(p):
if progress:
progress.change_message('Adding vcs analysis {}'.format(an.record_id))
#make necessary file structure
r_mkdir(root)
d = self._generate_analysis_dict(an)
with open(p, 'w') as fp:
yaml.dump(d, fp, indent=4, default_flow_style=False)
self.repo_manager.add(p, commit=commit)
return True
def func(x, prog, i, n):
repo, irrad, level, d = x
if prog:
prog.change_message('Freezing Flux {}{} Repository={}'.format(
irrad, level, repo))
root = os.path.join(paths.repository_dataset_dir, repo, 'flux',
irrad)
r_mkdir(root)
p = os.path.join(root, level)
if os.path.isfile(p):
dd = dvc_load(p)
dd.update(d)
dvc_dump(d, p)
added.append((repo, p))
def _update_text(self, tag, name, path_or_blob):
if not name:
self.debug('cannot update text with no name. tag={} name={}'.format(tag, name))
return
root = os.path.join(paths.meta_root, tag)
if not os.path.isdir(root):
r_mkdir(root)
p = os.path.join(root, name)
if os.path.isfile(path_or_blob):
shutil.copyfile(path_or_blob, p)
else:
with open(p, 'w') as wfile:
wfile.write(path_or_blob)
self.add(p, commit=False)
def _update_text(self, tag, name, path_or_blob):
if not name:
self.debug('cannot update text with no name. tag={} name={}'.format(tag, name))
return
root = os.path.join(paths.meta_dir, tag)
if not os.path.isdir(root):
r_mkdir(root)
p = os.path.join(root, name)
# action = 'updated' if os.path.isfile(p) else 'added'
if os.path.isfile(path_or_blob):
shutil.copyfile(path_or_blob, p)
else:
with open(p, 'w') as wfile:
wfile.write(path_or_blob)
self.add(p, commit=False)
def _apply_button_fired(self):
sel = self.selected
if not sel:
sel = self.found
for s in sel:
root = self.script_root
dest = os.path.join(root, 'backup', os.path.relpath(s.directory, root))
r_mkdir(dest)
destpath = os.path.join(dest, s.name)
self.info('backup script to {}'.format(destpath))
shutil.copyfile(s.path, destpath)
self._modify_file(s.path)
self.info('updated script {}'.format(s.path))
self._update_valve()
self._scan()
def _get_working_repo(self):
if not self._repo:
from git import Repo
p = self.build_repo
if not p:
self.information_dialog('Please set "build repo" in Updater Preferences')
return
if not os.path.isdir(p):
r_mkdir(p)
if self.remote:
url = 'https://github.com/{}.git'.format(self.remote)
repo = Repo.clone_from(url, p)
else:
self.information_dialog('Please set "remote" in Updater Preferences')
return
else:
repo = Repo(p)
self._repo = repo
return self._repo
def _apply_button_fired(self):
sel = self.selected
if not sel:
sel = self.found
for s in sel:
root = self.script_root
dest = os.path.join(root, 'backup',
os.path.relpath(s.directory, root))
r_mkdir(dest)
destpath = os.path.join(dest, s.name)
self.info('backup script to {}'.format(destpath))
shutil.copyfile(s.path, destpath)
self._modify_file(s.path)
self.info('updated script {}'.format(s.path))
self._update_valve()
self._scan()
def _make_multi_panel_labnumbers(self, ans, cnt):
root = self._config_options['root']
options = self._config_options['options']
# ans = [ai for li in lns for ai in li.analyses]
# ans = filter(lambda x: not x.tag == 'invalid', ans)
# prog = self.open_progress(len(ans), close_at_end=False)
# ans = self.make_analyses(ans,
# progress=prog,
# use_cache=False)
# print lns
lns = list({ai.labnumber.identifier for ai in ans})
print len(lns)
prog = None
pred = lambda x: bool(x.step)
ident = ','.join([li for li in lns])
li = ident
ident = '{:03d}-{}'.format(cnt, ident)
ln_root = os.path.join(root, ident)
r_mkdir(ln_root)
ans = sorted(ans, key=pred)
stepheat, fusion = map(list, partition(ans, pred))
project = 'Minna Bluff'
if stepheat and options.has_key('step_heat'):
# key = lambda x: x.aliquot
# stepheat = sorted(stepheat, key=key)
# for aliquot, ais in groupby(stepheat, key=key):
# name = make_runid(li, aliquot, '')
self._make_editor(
ans, 'step_heat', options, prog, False,
lambda x: '{}-{}'.format(x.identifier, x.aliquot),
(ln_root, 'spec', li, project, (li, )))
if fusion and options.has_key('fusion'):
self._make_editor(fusion, 'fusion', options, prog, False,
lambda x: x.identifier,
(ln_root, 'fig', li, project, (li, )))
def build(self, groups, path=None, options=None):
if options is None:
options = XLSXAnalysisTableWriterOptions()
self._options = options
if path is None:
path = options.path
self.debug('saving table to {}'.format(path))
r_mkdir(os.path.dirname(path))
self._new_workbook(path)
self._bold = self._workbook.add_format({'bold': True})
self._superscript = self._workbook.add_format({'font_script': 1})
self._subscript = self._workbook.add_format({'font_script': 2})
self._bsuperscript = self._workbook.add_format({
'font_script': 1,
'bold': True
})
self._bsubscript = self._workbook.add_format({
'font_script': 2,
'bold': True
})
self._ital = self._workbook.add_format({'italic': True})
unknowns = groups.get('unknowns')
if unknowns:
# make a human optimized table
unknowns = self._make_human_unknowns(unknowns)
# make a machine optimized table
munknowns = groups.get('machine_unknowns')
if munknowns:
self._make_machine_unknowns(munknowns)
airs = groups.get('airs')
if airs:
self._make_airs(airs)
blanks = groups.get('blanks')
if blanks:
self._make_blanks(blanks)
monitors = groups.get('monitors')
if monitors:
self._make_monitors(monitors)
# if not self._options.include_production_ratios:
# self._make_irradiations(unknowns)
if self._options.include_summary_sheet:
if unknowns:
self._make_summary_sheet(unknowns)
self._workbook.close()
view = self._options.auto_view
if not view:
view = confirm(
None, 'Table saved to {}\n\nView Table?'.format(path)) == YES
if view:
view_file(path, application='Excel')
def _easy_func(self, ep, manager):
db = self.manager.db
doc = ep.doc('ic')
# fits = doc['fits']
projects = doc['projects']
atype = doc['atype']
identifiers = doc.get('identifiers')
if identifiers:
# unks = [ai for proj in projects
# for si in db.get_samples(project=proj)
# for ln in si.labnumbers
# if str(ln.identifier) in identifiers
# for ai in ln.analyses
# if ai.measurement.mass_spectrometer.name.lower() in ('jan', 'obama')]
unks = [ai for ln in identifiers
for ai in db.get_labnumber(ln).analyses
if not ai.tag=='invalid']
else:
unks = [ai for proj in projects
for si in db.get_samples(project=proj)
for ln in si.labnumbers
for ai in ln.analyses
if ai.measurement.mass_spectrometer.name.lower() in ('jan', 'obama') and not ai.tag=='invalid']
prog = manager.progress
prog.increase_max(len(unks))
# preceding_fits, non_preceding_fits = map(list, partition(fits, lambda x: x['fit'] == 'preceding'))
# if preceding_fits:
# self.debug('preceding fits for ic_factors not implemented')
# for ai in unks:
# if prog.canceled:
# return
# elif prog.accepted:
# break
# l, a, s = ai.labnumber.identifier, ai.aliquot, ai.step
# prog.change_message('Save preceding blank for {}-{:02n}{}'.format(l, a, s))
# hist = db.add_history(ai, 'blanks')
# ai.selected_histories.selected_blanks = hist
# for fi in preceding_fits:
# self._preceding_correct(db, fi, ai, hist)
#make figure root dir
if doc['save_figures']:
root = doc['figure_root']
r_mkdir(root)
# if non_preceding_fits:
with no_auto_ctx(self.active_editor):
for ais in bin_analyses(unks):
if prog.canceled:
return
elif prog.accepted:
break
self.active_editor.set_items(ais, progress=prog)
self._set_analysis_type(atype, progress=prog)
self.active_editor.tool.trait_set(analysis_type=atype)
if not manager.wait_for_user():
return
if not manager.was_skipped():
#save a figure
if doc['save_figures']:
title = self.active_editor.make_title()
p = os.path.join(root, add_extension(title, '.pdf'))
self.active_editor.save_file(p)
self.active_editor.save(progress=prog)
self.active_editor.dump_tool()
return True
def _easy_func(self, ep, manager):
db=self.manager.db
doc = ep.doc('blanks')
fits = doc['blank_fit_isotopes']
projects = doc['projects']
unks = [ai for proj in projects
for si in db.get_samples(project=proj)
for ln in si.labnumbers
for ai in ln.analyses]
prog=manager.progress
# prog = self.manager.open_progress(len(ans) + 1)
#bin analyses
prog.increase_max(len(unks))
preceding_fits, non_preceding_fits=map(list,partition(fits, lambda x: x['fit']=='preceding'))
if preceding_fits:
for ai in unks:
if prog.canceled:
return
elif prog.accepted:
break
l, a, s = ai.labnumber.identifier, ai.aliquot, ai.step
prog.change_message('Save preceding blank for {}-{:02n}{}'.format(l, a, s))
hist = db.add_history(ai, 'blanks')
ai.selected_histories.selected_blanks = hist
for fi in preceding_fits:
self._preceding_correct(db, fi, ai, hist)
#make figure root dir
if doc['save_figures']:
root = doc['figure_root']
r_mkdir(root)
with no_auto_ctx(self.active_editor):
if non_preceding_fits:
for ais in bin_analyses(unks):
if prog.canceled:
return
elif prog.accepted:
break
self.active_editor.set_items(ais, progress=prog)
self.active_editor.find_references(progress=prog)
#refresh graph
invoke_in_main_thread(self.active_editor.rebuild_graph)
if not manager.wait_for_user():
return
#save a figure
if doc['save_figures']:
title=self.active_editor.make_title()
p=os.path.join(root, add_extension(title,'.pdf'))
self.active_editor.save_file(p)
self.active_editor.save(progress=prog)
self.active_editor.dump_tool()
return True
def _easy_func(self, ep, manager):
db = self.manager.db
doc = ep.doc('ic')
# fits = doc['fits']
projects = doc['projects']
atype = doc['atype']
identifiers = doc.get('identifiers')
if identifiers:
# unks = [ai for proj in projects
# for si in db.get_samples(project=proj)
# for ln in si.labnumbers
# if str(ln.identifier) in identifiers
# for ai in ln.analyses
# if ai.measurement.mass_spectrometer.name.lower() in ('jan', 'obama')]
unks = [
ai for ln in identifiers
for ai in db.get_labnumber(ln).analyses
if not ai.tag == 'invalid'
]
else:
unks = [
ai for proj in projects for si in db.get_samples(project=proj)
for ln in si.labnumbers for ai in ln.analyses
if ai.measurement.mass_spectrometer.name.lower() in (
'jan', 'obama') and not ai.tag == 'invalid'
]
prog = manager.progress
prog.increase_max(len(unks))
# preceding_fits, non_preceding_fits = map(list, partition(fits, lambda x: x['fit'] == 'preceding'))
# if preceding_fits:
# self.debug('preceding fits for ic_factors not implemented')
# for ai in unks:
# if prog.canceled:
# return
# elif prog.accepted:
# break
# l, a, s = ai.labnumber.identifier, ai.aliquot, ai.step
# prog.change_message('Save preceding blank for {}-{:02n}{}'.format(l, a, s))
# hist = db.add_history(ai, 'blanks')
# ai.selected_histories.selected_blanks = hist
# for fi in preceding_fits:
# self._preceding_correct(db, fi, ai, hist)
#make figure root dir
if doc['save_figures']:
root = doc['figure_root']
r_mkdir(root)
# if non_preceding_fits:
with no_auto_ctx(self.active_editor):
for ais in bin_analyses(unks):
if prog.canceled:
return
elif prog.accepted:
break
self.active_editor.set_items(ais, progress=prog)
self._set_analysis_type(atype, progress=prog)
self.active_editor.tool.trait_set(analysis_type=atype)
if not manager.wait_for_user():
return
if not manager.was_skipped():
#save a figure
if doc['save_figures']:
title = self.active_editor.make_title()
p = os.path.join(root, add_extension(title, '.pdf'))
self.active_editor.save_file(p)
self.active_editor.save(progress=prog)
self.active_editor.dump_tool()
return True
def _easy_func(self, ep, manager):
db = self.manager.db
doc = ep.doc('blanks')
fits = doc['blank_fit_isotopes']
projects = doc['projects']
unks = [ai for proj in projects
for si in db.get_samples(project=proj)
for ln in si.labnumbers
for ai in ln.analyses
if ai.measurement.mass_spectrometer.name == 'MAP'
and ai.extraction.extraction_device.name in ('Furnace', 'Eurotherm')]
# for proj in projects:
# for si in db.get_samples(project=proj):
# for ln in si.labnumbers:
# for ai in ln.analyses:
# print ai.measurement.mass_spectrometer.name,ai.extraction.extraction_device.name
# print ai.measurement.mass_spectrometer.name == 'nmgrl map' and ai.extraction.extraction_device.name in ('Furnace','Eurotherm')
print len(unks)
prog = manager.progress
# prog = self.manager.open_progress(len(ans) + 1)
#bin analyses
prog.increase_max(len(unks))
preceding_fits, non_preceding_fits = map(list, partition(fits, lambda x: x['fit'] == 'preceding'))
if preceding_fits:
for ai in unks:
if prog.canceled:
return
elif prog.accepted:
break
l, a, s = ai.labnumber.identifier, ai.aliquot, ai.step
prog.change_message('Save preceding blank for {}-{:02n}{}'.format(l, a, s))
hist = db.add_history(ai, 'blanks')
ai.selected_histories.selected_blanks = hist
for fi in preceding_fits:
self._preceding_correct(db, fi, ai, hist)
#make figure root dir
if doc['save_figures']:
root = doc['figure_root']
r_mkdir(root)
with no_auto_ctx(self.active_editor):
if non_preceding_fits:
for fi in self.active_editor.tool.fits:
fi.fit = 'average'
fi.error_type = 'SEM'
fi.filter_outliers = True
fi.filter_iterations = 1
fi.filter_std_devs = 2
for ais in bin_analyses(unks):
if prog.canceled:
return
elif prog.accepted:
break
self.active_editor.set_items(ais, progress=prog)
self.active_editor.find_references(progress=prog)
#refresh graph
# invoke_in_main_thread(self.active_editor.rebuild_graph)
#
# if not manager.wait_for_user():
# return
#save a figure
if doc['save_figures']:
title = self.active_editor.make_title()
p = os.path.join(root, add_extension(title, '.pdf'))
self.active_editor.save_file(p)
self.active_editor.save(progress=prog)
self.active_editor.dump_tool()
return True
