This function returns a list of all the epoch names in your recording

        Returns
        ----------
        epoch_names: list
            List of epoch names in the recording extractor
970413
def get_epoch_names(self):
        '''
        '''
        epoch_names = list(self._epochs.keys())
        if not epoch_names:
            pass
        else:
            epoch_start_frames = []
            for epoch_name in epoch_names:
                epoch_info = self.get_epoch_info(epoch_name)
                start_frame = epoch_info['start_frame']
                epoch_start_frames.append(start_frame)
            epoch_names = [epoch_name for _, epoch_name in sorted(zip(epoch_start_frames, epoch_names))]
        return epoch_names
278657
def extract_labels(self) -> np.ndarray:
        
        condition_idxs, epoch_idxs, _ = np.where(self)
        _, unique_epoch_idxs = np.unique(epoch_idxs, return_index=True)
        return condition_idxs[unique_epoch_idxs]
1158082
def recordings(self):
        
        if self._recordings is None:
            self._recordings = RoomRecordingList(self._version, room_sid=self._solution['sid'], )
        return self._recordings
82244
def sequencenames(contigsfile):
        
        sequences = list()
        for record in SeqIO.parse(open(contigsfile, "rU", encoding="iso-8859-15"), "fasta"):
            sequences.append(record.id)
        return sequences
1009644
def level_names(self):
        
        index = self.to_index()
        if isinstance(index, pd.MultiIndex):
            return index.names
        else:
            return None
458139
def get_record_params(args):
    
    name, rtype, content, ttl, priority = (
        args.name, args.rtype, args.content, args.ttl, args.priority)
    return name, rtype, content, ttl, priority
1098203
def record(self):
        

        modules = []
        scripts = []
        if self.get_content_of_file('RECORD'):
            lines = self.get_content_of_file('RECORD').splitlines()
            for line in lines:
                if 'dist-info' in line or '/' not in line:
                    continue
                elif '.data/scripts' in line:
                    script = line.split(',', 1)[0]
                    # strip Name.version.data/scripts/
                    scripts.append(re.sub('.*/.*/', '', script))
                else:
                    # strip everything from first occurance of slash
                    modules.append(re.sub('/.*', '', line))

        return {'modules': sorted(set(modules)),
                'scripts': sorted(set(scripts))}
802609
def prior_names(self):
        
        return list(self.prior_information.groupby(
                self.prior_information.index).groups.keys())
101673
def recording_settings(self):
        
        if self._recording_settings is None:
            self._recording_settings = RecordingSettingsList(self)
        return self._recording_settings
456046
def _get_coordinatenames(self):
        
        validnames = ("direction", "spectral", "linear", "stokes", "tabular")
        self._names = [""] * len(validnames)
        n = 0
        for key in self._csys.keys():
            for name in validnames:
                if key.startswith(name):
                    idx = int(key[len(name):])
                    self._names[idx] = name
                    n += 1
        # reverse as we are c order in python
        self._names = self._names[:n][::-1]

        if len(self._names) == 0:
            raise LookupError("Coordinate record doesn't contain valid coordinates")
592397
def all_recordings
      opts = {
        headers: true,
        header_converters: :symbol,
        encoding: 'utf-8'
      }
      CSV.read(DIFILE, opts).map(&:to_hash)
    end
544417
def nnz_obs_names(self):
        
        # nz_names = []
        # for w,n in zip(self.observation_data.weight,
        #                self.observation_data.obsnme):
        #     if w > 0.0:
        #         nz_names.append(n)
        obs = self.observation_data

        nz_names = list(obs.loc[obs.weight>0.0,"obsnme"])
        return nz_names
1133152
def get_layer_names(self):
    
    layer_names = [x.name for x in self.model.layers]
    return layer_names
1357101
def get_features_all(self):
        

        features = {}

        # Get all the names of features.
        all_vars = vars(self)
        for name in all_vars.keys():
            if name in feature_names_list_all:
                features[name] = all_vars[name]

        # Sort by the keys (i.e. feature names).
        features = OrderedDict(sorted(features.items(), key=lambda t: t[0]))

        return features
585176
def _load_names(self) -> List[str]:
        
        names = []
        for path in self._get_files():
            for name in self._get_names(path):
                names.append(self._normalize_name(name))
        return names
550336
def get_field_names(self):
        
        field_names = super(StationDataIO, self).get_field_names()
        if set(field_names) == set(['meta', 'data']):
            meta_fields = list(self.data[0]['meta'].keys())
            if set(meta_fields) < set(self.getvalue('meta')):
                meta_fields = self.getvalue('meta')
            field_names = list(meta_fields) + ['data']
        return field_names
916049
def extract_fieldnames(config):
    
    fields = []
    for x in get_fields(config):
        if x in fields:
            fields.append(x + '_' + str(fields.count(x) + 1))
        else:
            fields.append(x)
    return fields