Search and return all steps that have no parents. These are the steps that are get the input data.
183423
def _get_input_steps(self):
        
        input_steps = []

        for step in self.steps_sorted:
            parent_steps = self._parent_steps(step)

            if len(parent_steps) == 0:
                input_steps.append(step)

        return input_steps
168277
public function childStepFamilies(): Collection
    {
        $step_families = [];
        $families      = $this->childFamilies();
        foreach ($families as $family) {
            $father = $family->husband();
            if ($father) {
                foreach ($father->spouseFamilies() as $step_family) {
                    if (!$families->containsStrict($step_family)) {
                        $step_families[] = $step_family;
                    }
                }
            }
            $mother = $family->wife();
            if ($mother) {
                foreach ($mother->spouseFamilies() as $step_family) {
                    if (!$families->containsStrict($step_family)) {
                        $step_families[] = $step_family;
                    }
                }
            }
        }

        return new Collection($step_families);
    }
1078377
public java.util.List<RemediationExecutionStep> getStepDetails() {
        if (stepDetails == null) {
            stepDetails = new com.amazonaws.internal.SdkInternalList<RemediationExecutionStep>();
        }
        return stepDetails;
    }
1186620
private int getPreviousStep(int currentStep) {
        int prevStep = -1;

        // we find the next available step.
        for (int i = currentStep - 1; i >= STEP_LOGIN; i--) {
            if(isStepEnabled(i)) {
                prevStep = i;
                break;
            }
        }

        return prevStep;
    }
963777
def no_possible_matches_in_subdirs(self):
        """"""
        return (not self.parent_has_patterns and self.matched_inherit.empty()
                and self.matched_and_subdir.empty() and self.unmatched.empty())
745690
def downstream(self, step_name):
        """"""
        return list(self.steps[dep] for dep in self.dag.downstream(step_name))
216712
def get_ancestors(self, include_self=False, depth=None):
        """"""
        if self.is_root_node():
            if not include_self:
                return self._toplevel().objects.none()
            else:
                # Filter on pk for efficiency.
                return self._toplevel().objects.filter(pk=self.pk)

        params = {"%s__child" % self._closure_parentref():self.pk}
        if depth is not None:
            params["%s__depth__lte" % self._closure_parentref()] = depth
        ancestors = self._toplevel().objects.filter(**params)
        if not include_self:
            ancestors = ancestors.exclude(pk=self.pk)
        return ancestors.order_by("%s__depth" % self._closure_parentref())
995150
@Override
    public void step(INDArray parameters, INDArray searchDirection, double step) {
        Nd4j.getBlasWrapper().level1().axpy(searchDirection.length(), step, searchDirection, parameters);
    }
699585
def ancestors(self):
        
        ancestors = []
        p = self.parent
        while p is not None:
            ancestors.append(p)
            p = p.parent
        return ancestors
873200
def get_siblings(self):
        
        qset = get_result_class(self.__class__).objects.filter(
            depth=self.depth
        ).order_by(
            'path'
        )
        if self.depth > 1:
            # making sure the non-root nodes share a parent
            parentpath = self._get_basepath(self.path, self.depth - 1)
            qset = qset.filter(
                path__range=self._get_children_path_interval(parentpath))
        return qset
497703
def _step(self) -> typing.Union[None, 'projects.ProjectStep']:
        
        import cauldron
        try:
            return cauldron.project.get_internal_project().current_step
        except Exception:
            return None
984705
public PossibleStep findMatchedStep(Step step)
	{
		for (PossibleStep possibleStep : possibleSteps)
		{
			if (possibleStep.getStepType().equals(step.getStepType()))
			{
				if (possibleStep.getRegexStepMatcher().matches(step.getCombinedStepLines()))
				{
					return possibleStep;
				}
			}
		}
		return null;
	}
1333639
def get_next_step(self):
        
        subcategory = self.parent.step_kw_subcategory.selected_subcategory()
        is_raster = is_raster_layer(self.parent.layer)
        has_classifications = get_classifications(subcategory['key'])

        # Vector
        if not is_raster:
            return self.parent.step_kw_field
        # Raster and has classifications
        elif has_classifications:
            return self.parent.step_kw_multi_classifications
        # else go to source
        return self.parent.step_kw_source
558263
def fetch(self):
        
        params = values.of({})

        payload = self._version.fetch(
            'GET',
            self._uri,
            params=params,
        )

        return StepInstance(
            self._version,
            payload,
            flow_sid=self._solution['flow_sid'],
            engagement_sid=self._solution['engagement_sid'],
            sid=self._solution['sid'],
        )
988829
protected function getSteps() {
        if (!$this->_steps) {
            $this->_steps = new StepList($this->version, $this->solution['flowSid'], $this->solution['sid']);
        }

        return $this->_steps;
    }
525012
def get_inputs_helper(step, ignore, target):
    
    outputs = set()
    if not ignore and step.target == target:
        outputs.add(step)

    if ignore or not step.target:
        for i in step.inputs:
            outputs.update(get_inputs_helper(i, ignore=False, target=target))

    return outputs
896394
@Override
    protected void searchStep() {
        // check: valid subset size range completely explored?
        if(validSubsetSizeRangeExplored()){
            // we are done
            stop();
        } else {
            int numAdd, numDel;
            if(isIncreasing()){
                // perform L additions
                numAdd = greedyMoves(l, singleAddNeigh);
                // perform number of deletions (<= R) that yields a delta of |L-R|,
                // taking into account the actual number of added items
                numDel = numAdd - getDelta();
                greedyMoves(numDel, singleDelNeigh);
            } else {
                // perform R deletions
                numDel = greedyMoves(r, singleDelNeigh);
                // perform number of additions (<= L) that yields a delta of |L-R|,
                // taking into account the actual number of deleted items
                numAdd = numDel - getDelta();
                greedyMoves(numAdd, singleAddNeigh);
            }
            if(numAdd == 0 || numDel == 0){
                stop();
            }
        }
    }