Returns dependency properties.
765405
def dependency (self):
        
        result = [p for p in self.lazy_properties if p.feature.dependency]
        result.extend(self.dependency_)
        return self.dependency_
660173
def _GetDeps(self, dependencies):
    

    for dependency in dependencies:
      dep_desc = self.FindFileByName(dependency)
      yield dep_desc
      for parent_dep in dep_desc.dependencies:
        yield parent_dep
915169
private Properties getArtifactProperties() {
        Properties properties = new Properties();
        try (InputStream stream = Main.class.getResourceAsStream("/project.properties")) {
            properties.load(stream);
        } catch (IOException e) {
            logger.error("Failed to get version ", e);
        }
        return properties;
    }
277569
public Set<String> getDependenciesNotation() {
        Set<String> notations = new HashSet<String>();
        
        for (Dependency dependency : currentDependencies() ) {
            notations.add(Notation.generate(dependency));
        }

        return notations;
    }
234945
def _get_dependency_specification(dep_spec: typing.List[tuple]) -> str:
    """"""
    return ",".join(dep_range[0] + dep_range[1] for dep_range in dep_spec)
592708
@PublicAPI(usage = ACCESS)
    public Set<Dependency> getDirectDependenciesToSelf() {
        ImmutableSet.Builder<Dependency> result = ImmutableSet.builder();
        result.addAll(dependenciesFromAccesses(getAccessesToSelf()));
        result.addAll(inheritanceDependenciesToSelf());
        result.addAll(fieldDependenciesToSelf());
        result.addAll(returnTypeDependenciesToSelf());
        result.addAll(methodParameterDependenciesToSelf());
        result.addAll(throwsDeclarationDependenciesToSelf());
        result.addAll(constructorParameterDependenciesToSelf());
        return result.build();
    }
134953
def get_dependencies(self):
    """"""
    producer_infos = set()
    for product_type in self._dependencies:
      producer_infos.update(self._get_producer_infos_by_product_type(product_type))
    return producer_infos
210949
def _get_depencency_var_name(self, dependency):
        
        for dep_path, var_name in self.dependencies:
            if dep_path == dependency:
                return var_name
950545
def get_dependency_graph(component):
    
    if component not in DEPENDENCIES:
        raise Exception("%s is not a registered component." % get_name(component))

    if not DEPENDENCIES[component]:
        return {component: set()}

    graph = defaultdict(set)

    def visitor(c, parent):
        if parent is not None:
            graph[parent].add(c)

    walk_dependencies(component, visitor)

    graph = dict(graph)

    # Find all items that don't depend on anything.
    extra_items_in_deps = _reduce(set.union, graph.values(), set()) - set(graph.keys())

    # Add empty dependencies where needed.
    graph.update(dict((item, set()) for item in extra_items_in_deps))

    return graph
682694
def depends_on(self, dependency):
        
        packages = self.package_info()
        return [package for package in packages if dependency in package.get("requires", "")]
503826
public function getDependencies()
    {
        $dependencies = array();

        $file = $this->getFilePath();
        if ($file) {
            $dependencies[] = $file;
        }

        foreach ($this->operations as $operation) {
            foreach ($operation[1] as $argument) {
                if ($argument instanceof self) {
                    $dependencies = array_merge($dependencies, $argument->getDependencies());
                }
            }
        }

        return $dependencies;
    }
1168052
private DependencyInfo getDependencyInfo(String symbol) {
    for (DependencyFile depsFile : depsFiles) {
      DependencyInfo di = depsFile.getDependencyInfo(symbol);
      if (di != null) {
        return di;
      }
    }
    return null;
  }
6642
def __generate_dependency_tree(self):
        
        dependency_dict = {}
        for s in self.manifest.sections():
            if s != "config":
                if self.manifest.has_option(s, 'depends'):
                    dependency_list = [d.strip() for d in re.split('\n|,', self.manifest.get(s, 'depends'))]
                    dependency_dict[s] = dependency_list
                else:
                    dependency_dict[s] = []
        try:
            return DependencyTree(dependency_dict)
        except DependencyTreeException:
            dte = sys.exc_info()[1]
            raise ManifestException("Dependency tree for manifest is invalid! %s" % str(dte))
742048
def dependencies_as_list(self):
        """"""
        dependencies = []
        for dependency in self.dependencies:
            dependencies.append(dependency.name)
        return dependencies
808684
private Set<JSModule> getTransitiveDeps(JSModule m) {
    Set<JSModule> deps = dependencyMap.computeIfAbsent(m, JSModule::getAllDependencies);
    return deps;
  }
836624
def properties(self):
        '''
        
        '''
        props = {}
        for line in self.adb_shell(['getprop']).splitlines():
            m = _PROP_PATTERN.match(line)
            if m:
                props[m.group('key')] = m.group('value')
        return props
248511
def dependency_map(self):
        

        """
        dtree = self.dependency_graph()
        fig = nx.draw_spectral(dtree,
                               with_labels=True,
                               arrowsize=50,
                               node_size=2000,
                               edge_color='lightgrey',
                               width=3.0,
                               font_size=32,
                               font_weight='bold')
        return fig