Return the SGF filename for each existing eval record.
503157
def read_existing_paths(bt_table):
    """"""
    rows = bt_table.read_rows(
        filter_=row_filters.ColumnRangeFilter(
            METADATA, SGF_FILENAME, SGF_FILENAME))
    names = (row.cell_value(METADATA, SGF_FILENAME).decode() for row in rows)
    processed = [os.path.splitext(os.path.basename(r))[0] for r in names]
    return processed
933697
def get_open_filenames(self):
        """"""
        editorstack = self.editorstacks[0]
        filenames = []
        filenames += [finfo.filename for finfo in editorstack.data]
        return filenames
1148818
def list_records(self, file_const=None):
        """"""
        for r in self._dataset.files:
            if file_const and r.minor_type != file_const:
                continue
            yield self.instance_from_name(r.path)
294458
def _evaluate_lookup(self, key, value, negated, db):
        """"""
        results = {}
        for record_key, record_value in db.items():
            match = True

            stripped_key, lookup_class = self._extract_lookup(key)
            lookup = lookup_class(record_value[stripped_key], value)

            if negated:
                match &= not eval(lookup.as_expression())
            else:
                match &= eval(lookup.as_expression())

            if match:
                results[record_key] = record_value

        return results
964258
def _get_filename(self):
        """"""
        if self._fname is None:
            timestamp = datetime.datetime.now().strftime("%Y%m%d-%H%M%S")
            fname = "%s-%s.log" % (timestamp, abs(id(self)))
            self._fname = os.path.join(self.file_path, fname)
        return self._fname
196925
def file_names(self) -> Iterable[str]:
        
        if self.is_sharded():
            yield from ShardedFile(self.filename_spec).get_filenames()
        elif self.filename_spec:
            yield self.filename_spec
436609
def get_isd_filenames(self, year=None, with_host=False):
        
        return get_isd_filenames(self.usaf_id, year, with_host=with_host)
385692
def all_dssp_props(filename, file_type):
    '''
    '''
    t = dssp_dataframe(filename, file_type)
    # print(t)
    sasa = calc_sasa(t)
    sstr = secondary_structure_summary(t)
    subu = calc_surface_buried(t)

    sasa.update(sstr)
    sasa.update(subu)

    return sasa
1279610
def retrieveVals(self):
        """"""
        file_stats = self._fileInfo.getContainerStats()
        for contname in self._fileContList:
            stats = file_stats.get(contname)
            if stats is not None:
                if self.hasGraph('rackspace_cloudfiles_container_size'):
                    self.setGraphVal('rackspace_cloudfiles_container_size', contname,
                                     stats.get('size'))
                if self.hasGraph('rackspace_cloudfiles_container_count'):
                    self.setGraphVal('rackspace_cloudfiles_container_count', contname,
                                     stats.get('count'))
1155798
def _variant_eval_metrics(self, dup_bam):
        
        base, ext = os.path.splitext(dup_bam)
        end_strip = "-dup"
        base = base[:-len(end_strip)] if base.endswith(end_strip) else base
        mfiles = glob.glob("%s*eval_metrics" % base)
        if len(mfiles) > 0:
            with open(mfiles[0]) as in_handle:
                # pull the metrics as JSON from the last line in the file
                for line in in_handle:
                    pass
                metrics = json.loads(line)
            return metrics
        else:
            return None
373290
def eval(self):
        
        if self.magic:
            return self.magic
        if not self.filename:
            return file_pattern.format(self.alias, self.ext)
        return self.path
895204
def get_filename(self, runSetName, fileExtension):
        '''
        
        '''

        fileName = self.benchmark.output_base_name + ".results."

        if runSetName:
            fileName += runSetName + "."

        return fileName + fileExtension
742528
function fileScope(filename) {
    filename = path.resolve('', filename || '');
    var result = scopes[filename];
    if (!result) {
      result = create({
        clean: clean,
        removeList: removeList,
        excludeList: excludeList,
        rootScope: rootScope,
        filename: filename,
        argv: argv,
        scopes: scopes,
        processors: processors,
        variants: variants,
        cacheKeys: cacheKeys,
        tags: tags
      });
    }
    return result;
  }
849720
def getSaveFileName(*args):
        
        result = QtGui.QFileDialog.getSaveFileName(*args)
        
        # PyQt4 returns just a string
        if type(result) is not tuple:
            return result, bool(result)
        
        # PySide returns a tuple of str, bool
        else:
            return result
62262
def eval(s, bndng=nil, filename=nil, lineno=nil)

      loadstring_and_call(s, bndng, filename, lineno)
    end
929838
def get_db_name(self, fname):
        """"""
        return self.funcs.db_func(fname, self.outdir, self.exes.format_exe)[1]
1223883
def version_by_eval(self, file_path):  # type: (str) ->Dict[str,str]
        
        source = self.file_opener.read_this(file_path)
        sb = "{"
        for line in source.split("\n"):
            if "=" in line:
                parts = line.split("=")
                sb += "'" + parts[0] + "':" + parts[1]
        sb += "}"
        if sb == "{}":
            return {}
        try:
            thing = ast.literal_eval(sb)
        except:
            return {}
        for version_token in dunder_version.version_tokens:
            if version_token in thing:
                return {"literal_eval": thing[version_token]}
        return {}