List(int): Entry IDs for stages that were inputs for this stage.
14977
def input_stages(self):
        """"""
        if self._properties.get("inputStages") is None:
            return []
        return [
            _helpers._int_or_none(entry)
            for entry in self._properties.get("inputStages")
        ]
96960
public List<Entry> getEntries() {
        List<Entry> allEntries = new ArrayList<Entry>();

        if (root != null) {
            getEntries(root, allEntries);
        }

        return allEntries;
    }
290901
def get_ids(cs):
    """"""
    records = []
    for c in cs:
        records.append({k: c[k] for k in c if k in {'names', 'labels'}})
    return records
641781
def _get_validated_stages(stages):
    
    if not isinstance(stages, list):
        raise WorkflowBuilderException("Stages must be specified as a list of dictionaries")
    validated_stages = []
    for index, stage in enumerate(stages):
        validated_stages.append(_get_validated_stage(stage, index))
    return validated_stages
699860
public static void addIds(List<Entry> entries, boolean updateRdn) {
        for (Entry entry : entries) {
            addId(entry, updateRdn);
        }
    }
415229
def neurite_root_section_ids(self):
        ''''''
        sec = self.sections
        return [i for i, ss in enumerate(sec)
                if ss.pid > -1 and (sec[ss.pid].ntype == POINT_TYPE.SOMA and
                                    ss.ntype != POINT_TYPE.SOMA)]
843000
def get_stages(self):
        '''
        
        '''
        sequence = self.get_sequence()
        stages = {}
        for seq in self._sequences:
            for e in seq:
                if e.src.get_name() not in stages:
                    stages[e.src.get_name()] = []
                if e.dst.get_name() not in stages[e.src.get_name()]:
                    stages[e.src.get_name()].append(e.dst.get_name())
        return {
            'current': [e.dst.get_name() for e in sequence],
            'stages': stages
        }
64850
def learn_ids(self, item_list):
        
        self._reset_sequence()
        for item in item_list:
            key = self.nondup_key_for_item(item)
            self.ids[key] = item[self.id_key]
1152822
def entries(self):
        """"""
        self.meta.seek(self.file_list_start)
        for i in range(0, self.num_files):
            yield self._get_node()
58599
def relevantindices(self) -> List[int]:
        """"""
        return [idx for idx in numpy.unique(self.refindices.values)
                if idx in self.RELEVANT_VALUES]
424056
def stage_input(self):
        """"""

        if self.workdir == self.outdir:
            return
        elif not os.path.isdir(self.workdir):
            self.logger.error('Working directory does not exist.')
            return

        self.logger.info('Staging files to %s', self.workdir)

        files = [os.path.join(self.outdir, f)
                 for f in os.listdir(self.outdir)]

        regex = copy.deepcopy(self.config['fileio']['workdir_regex'])

        for f in files:

            if not os.path.isfile(f):
                continue
            if not utils.match_regex_list(regex, os.path.basename(f)):
                continue

            self.logger.debug('Copying ' + os.path.basename(f))
            shutil.copy(f, self.workdir)

        for c in self.components:
            for f in c.files.values():

                if f is None:
                    continue

                wpath = os.path.join(self.workdir, os.path.basename(f))
                opath = os.path.join(self.outdir, os.path.basename(f))

                if os.path.isfile(wpath):
                    continue
                elif os.path.isfile(opath):
                    self.logger.debug('Copying ' + os.path.basename(f))
                    shutil.copy(opath, self.workdir)

        self.logger.info('Finished.')
41573
def ids(self):
        """"""
        as_list = [seq.description.split()[0] for seq in self]
        as_set = frozenset(as_list)
        assert len(as_set) == len(as_list)
        return as_set
194530
def ids(self):
        """"""
        assert self.name == "Materials"
        ids = list()
        for attr in self.attrs:
            attr_obj = getattr(self, attr)
            if hasattr(attr_obj, 'Id'):
                ids.append(getattr(attr_obj, 'Id'))
        return ids
274549
def list_entrypoints(entry_point):
    """"""
    found_entry_points = {}
    for dist in working_set:
        entry_map = dist.get_entry_map()
        for group_name, entry_points in entry_map.items():
            # Filter entry points
            if entry_point is None and \
               not group_name.startswith('invenio'):
                continue
            if entry_point is not None and \
               entry_point != group_name:
                continue

            # Store entry points.
            if group_name not in found_entry_points:
                found_entry_points[group_name] = []
            for ep in entry_points.values():
                found_entry_points[group_name].append(str(ep))

    for ep_group in sorted(found_entry_points.keys()):
        click.secho('{0}'.format(ep_group), fg='green')
        for ep in sorted(found_entry_points[ep_group]):
            click.echo('  {0}'.format(ep))
595904
def _validate_entities(self, stages):
        
        if not stages:
            raise TypeError(expected_type=Stage, actual_type=type(stages))

        if not isinstance(stages, list):
            stages = [stages]

        for value in stages:
            if not isinstance(value, Stage):
                raise TypeError(expected_type=Stage, actual_type=type(value))

        return stages
38749
def getLeaves(self):
        """"""
        result = list()
        if not self._next_stages:
            result.append(self)
        else:
            for stage in self._next_stages:
                leaves = stage.getLeaves()
                result += leaves
        return result
1201941
public List<String> getCurrentStages(Long processId, boolean reload) {
        if (reload) {
            reload(processId);
        }

        List<String> stages = currentStages.get(processId);
        if (stages == null) {
            stages = new ArrayList<String>();
        }
        return stages;
    }