def get_file_path(root, action='open'):
    dlg = FileDialog(action=action,
                     wildcard=FileDialog.create_wildcard('YAML', '*.yaml *.yml'),
                     default_directory=root)
    if dlg.open():
        if dlg.path:
            return add_extension(dlg.path, ext=('.yaml', '.yml'))

    def dump(self):
        p = os.path.join(paths.hidden_dir, add_extension('config', '.p'))
        with open(p, 'wb') as wfile:
            obj = {'name': self.active_name}
            pickle.dump(obj, wfile)

        self.dump_item(self.active_item)

    def _save_(self, type_='pic', path=None):
        """
        """
        if path is None:
            dlg = FileDialog(action='save as', default_directory=os.path.expanduser('~'))
            if dlg.open() == OK:
                path = dlg.path
                self.status_text = 'Image Saved: %s' % path

        if path is not None:
            if type_ == 'pdf' or path.endswith('.pdf'):
                self._render_to_pdf(filename=path)
            else:
                # auto add an extension to the filename if not present
                # extension is necessary for PIL compression
                # set default save type_ DEFAULT_IMAGE_EXT='.png'

                # see http://infohost.nmt.edu/tcc/help/pubs/pil/formats.html
                saved = False
                for ei in IMAGE_EXTENSIONS:
                    if path.endswith(ei):
                        self._render_to_pic(path)
                        saved = True
                        break

                if not saved:
                    self._render_to_pic(add_extension(path, DEFAULT_IMAGE_EXT))

 def get_production(self, pname, **kw):
     root = os.path.join(paths.meta_dir, 'productions')
     if not os.path.isdir(root):
         os.mkdir(root)
     p = os.path.join(root, add_extension(pname))
     ip = Production(p)
     return ip

    def _gain_path(self, name):
        root = os.path.join(paths.meta_dir, 'spectrometers')
        if not os.path.isdir(root):
            os.mkdir(root)

        p = os.path.join(root, add_extension('{}.gain'.format(name), '.json'))
        return p

def save_csv(record_id, items):
    path = os.path.join(paths.data_det_ic_dir, add_extension(record_id, '.csv'))
    with open(path, 'w') as wfile:
        wrt = csv.writer(wfile, delimiter='\t')
        wrt.writerow(['#det', 'intensity', 'err'] + DETECTOR_ORDER)
        for i in items:
            wrt.writerow(i.to_row())

 def dump_item(self, item):
     name = item.name
     p = os.path.join(self.root, add_extension(name, '.p'))
     print('dump itme')
     with open(p, 'wb') as wfile:
         pickle.dump(item, wfile)
         print('sdfasdf')

    def make_gosub(self):
        selection = self.control.code.textCursor().selectedText()
        dlg = FileDialog(action='save as',
                         default_directory=os.path.dirname(self.path))

        p = None
        # root = os.path.dirname(self.path)
        # p = os.path.join(root, 'common', 'test_gosub.py')
        if dlg.open():
            p = dlg.path

        if p:
            p = add_extension(p, '.py')
            # p='/Users/ross/Desktop/foosub.py'
            with open(p, 'w') as wfile:
                wfile.write('# Extracted Gosub\n')
                wfile.write('# Source: from {}\n'.format(self.path))
                wfile.write('# Date: {}\n'.format(datetime.now().strftime('%m-%d-%Y %H:%M')))
                wfile.write('def main():\n')
                for li in selection.split(u'\u2029'):
                    wfile.write(u'    {}\n'.format(li.lstrip()))

            p = remove_extension(p)
            rp = os.path.relpath(p, self.path)
            rp = rp.replace('/', ':')
            self.control.code.replace_selection("gosub('{}')".format(rp[3:]))

    def _execute_extraction(self, name, root, kind, new_thread=True,
                            delay_start=0,
                            on_completion=None,
                            context=None):
        from pychron.pyscripts.extraction_line_pyscript import ExtractionPyScript

        klass = ExtractionPyScript
        if kind == 'Laser':
            from pychron.pyscripts.laser_pyscript import LaserPyScript

            klass = LaserPyScript

        script = klass(application=self.application,
                       root=root,
                       name=add_extension(name, '.py'),
                       runner=self._runner)

        if script.bootstrap():
            if context:
                script.setup_context(**context)
            else:
                script.set_default_context()
            try:
                script.test()
            except Exception, e:
                return
            self._current_script = script
            script.setup_context(extract_device='fusions_diode')
            if self.use_trace:
                self.active_editor.trace_delay = self.trace_delay

            ret = script.execute(trace=self.use_trace, new_thread=new_thread, delay_start=delay_start,
                                 on_completion=on_completion)
            return not script.is_canceled() and ret

    def _get_save_path(self, path, ext='.pdf'):
        if path is None:
            dlg = FileDialog(action='save as', default_directory=paths.processed_dir)
            if dlg.open():
                if dlg.path:
                    path = add_extension(dlg.path, ext)

        return path

 def load_spectrometer_parameters(self, spec_sha):
     if spec_sha:
         name = add_extension(spec_sha, '.json')
         p = repository_path(self.repository_identifier, name)
         sd = get_spec_sha(p)
         self.source_parameters = sd['spectrometer']
         self.gains = sd['gains']
         self.deflections = sd['deflections']

 def _prepare(self, extraction_script):
     extraction_script = add_extension(extraction_script)
     task = self.pyscript_task
     root, name = os.path.split(extraction_script)
     ctx = {'analysis_type': 'blank' if 'blank' in name else 'unknown'}
     ret = task.execute_script(name, root, new_thread=False, context=ctx)
     self.info('Extraction script {} {}'.format(name, 'completed successfully' if ret else 'failed'))
     return ret

 def save_as(self):
     if self._validate_sequence():
         dialog = FileDialog(action='save as', default_directory=paths.hops_dir)
         if dialog.open() == OK:
             p = dialog.path
             p = add_extension(p, '.txt')
             self._save_file(p)
             self.path = p

    def get(self, name):
        p = os.path.join(paths.peak_center_config_dir, add_extension(name, '.p'))
        if os.path.isfile(p):
            with open(p, 'rb') as rfile:
                obj = pickle.load(rfile)
        else:
            obj = self.item_klass()

        return obj

 def _get_gosub_text(self, gosub):
     root = os.path.dirname(self.path)
     new = gosub.replace('/', ':')
     new = add_extension(new, '.py')
     paths = new.split(':')
     p = os.path.join(root, *paths)
     if os.path.isfile(p):
         with open(p, 'r') as rfile:
             return rfile.read()

    def add_production_to_irradiation(self, irrad, name, params, add=True, commit=False):
        self.debug('adding production {} to irradiation={}'.format(name, irrad))
        p = os.path.join(paths.meta_root, irrad, 'productions', add_extension(name, '.json'))
        prod = Production(p, new=not os.path.isfile(p))

        prod.update(params)
        prod.dump()
        if add:
            self.add(p, commit=commit)

 def experiment_blob(self):
     path = self.experiment_queue.path
     path = add_extension(path, '.txt')
     if os.path.isfile(path):
         with open(path, 'r') as fp:
             return '{}\n{}'.format(path,
                                    fp.read())
     else:
         self.warning('{} is not a valid file'.format(path))

 def _script_factory(self, script_name):
     if os.path.isfile(os.path.join(paths.extraction_dir, add_extension(script_name, '.py'))):
         runner = self.application.get_service('pychron.extraction_line.ipyscript_runner.IPyScriptRunner')
         script = ExtractionPyScript(root=paths.extraction_dir,
                                     name=script_name,
                                     manager=self.extraction_line_manager,
                                     allow_lock=True,
                                     runner=runner)
         return script

    def make_irradiation_load_template(self):
        path = self.save_file_dialog()
        if path:
            # p = '/Users/ross/Sandbox/irrad_load_template.xls'
            path = add_extension(path, ".xls")
            self.manager.make_irradiation_load_template(path)

            self.information_dialog("Template saved to {}".format(path))
            self.view_xls(path)

    def export_data(self, path=None, plotid=None):
        """
        """
        if path is None:
            path = get_file_path()

        if path is not None:
            path = add_extension(path, '.csv')
            self._export_data(path, plotid)