Accesses basic dependencies from the XML output

        :getter: Returns the dependency graph for basic dependencies
        :type: corenlp_xml.dependencies.DependencyGraph
492145
def basic_dependencies(self):
        
        if self._basic_dependencies is None:
            deps = self._element.xpath('dependencies[@type="basic-dependencies"]')
            if len(deps) > 0:
                self._basic_dependencies = DependencyGraph(deps[0])
        return self._basic_dependencies
128236
def get_dependency_extractor(self):
        
        if self.dependency_layer is not None:    #otherwise there are no dependencies
            if self.my_dependency_extractor is None:
                self.my_dependency_extractor = Cdependency_extractor(self)
            return self.my_dependency_extractor
        else:
            return None
879586
def get_dependencies_from_decl(decl, recursive=True):
    
    result = []
    if isinstance(decl, typedef.typedef_t) or \
            isinstance(decl, variable.variable_t):
        return [dependency_info_t(decl, decl.decl_type)]
    if isinstance(decl, namespace.namespace_t):
        if recursive:
            for d in decl.declarations:
                result.extend(get_dependencies_from_decl(d))
        return result
    if isinstance(decl, calldef.calldef_t):
        if decl.return_type:
            result.append(
                dependency_info_t(decl, decl.return_type, hint="return type"))
        for arg in decl.arguments:
            result.append(dependency_info_t(decl, arg.decl_type))
        for exc in decl.exceptions:
            result.append(dependency_info_t(decl, exc, hint="exception"))
        return result
    if isinstance(decl, class_declaration.class_t):
        for base in decl.bases:
            result.append(
                dependency_info_t(
                    decl,
                    base.related_class,
                    base.access_type,
                    "base class"))
        if recursive:
            for access_type in class_declaration.ACCESS_TYPES.ALL:
                result.extend(
                    __find_out_member_dependencies(
                        decl.get_members(access_type), access_type))
        return result
    return result
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
765405
def dependency (self):
        
        result = [p for p in self.lazy_properties if p.feature.dependency]
        result.extend(self.dependency_)
        return self.dependency_
1345711
def traverse_dependencies_up(docgraph, node_id, node_attr=None):
    
    # there's only one, but we're in a multidigraph
    source, target = docgraph.in_edges(node_id)[0]
    traverse_attr = node_attr if node_attr else docgraph.lemma_attr

    attrib_value = docgraph.node[source].get(traverse_attr)
    if attrib_value:
        yield attrib_value

    if istoken(docgraph, source) is True:
        for attrib_value in traverse_dependencies_up(docgraph, source,
                                                     traverse_attr):
            yield attrib_value
825081
public List<TypedDependency> getStanfordTypedDependencies(DependencyForm form) {
        List<TypedDependency> dependencies = new ArrayList<TypedDependency>();
        if (this.nodes == null)
        	nodes = getStanfordTreeGraphNodes(form);

        List<AgigaTypedDependency> agigaDeps = getAgigaDeps(form);
        for (AgigaTypedDependency agigaDep : agigaDeps) {
            // Add one, since the tokens are zero-indexed but the TreeGraphNodes are one-indexed
            TreeGraphNode gov = nodes.get(agigaDep.getGovIdx() + 1);
            TreeGraphNode dep = nodes.get(agigaDep.getDepIdx() + 1);
            // Create the typed dependency
            TypedDependency typedDep = new TypedDependency(GrammaticalRelation.valueOf(agigaDep.getType()), gov, dep);
            dependencies.add(typedDep);
        }
        return dependencies;
    }
465910
def dependent(self):
        
        if self._dependent is None:
            dependents = self._element.xpath('dependent')
            if len(dependents) > 0:
                self._dependent = DependencyNode.load(self._graph, dependents[0])
        return self._dependent
7420
function buildDependencyGraph(module, dependencies, graph) {
	if (module && !graph[module]) {
		graph[module] = [];
	}

	var dependencyNames = Object.keys(dependencies);
	dependencyNames.forEach(function(dependencyName) {
		var dependency = dependencies[dependencyName];

		if (module && graph[module].indexOf(dependencyName) === -1) {
			graph[module].push(dependencyName);
		}

		// Traverse down to this dependency dependencies:
		// Dependency-ception.
		if (dependency.dependencies) {
			buildDependencyGraph(dependencyName, dependency.dependencies, graph);
		}
	});
}
914681
private Collection<DependencyInfo> collectChildrenDependencies(DependencyInfo dependency, List<String> groupLines) {
        logger.debug("Collect child dependencies of {}, total group-lines = {}", dependency.getGroupId(), groupLines.size());
        Collection<DependencyInfo> dependencies = new LinkedList<>();
        boolean dependencyLine = false;
        for (String line : groupLines) {
            if (!dependencyLine && line.startsWith(FOUR_SPACES + dependency.getGroupId() + Constants.WHITESPACE)) {
                dependencyLine = true;
                getDependencyFromLine(dependency, line);
            } else if (dependencyLine) {
                if (line.startsWith(SIX_SPACES)) {
                    DependencyInfo childDependency = new DependencyInfo();
                    String lineWithoutSpaces = line.substring(SIX_SPACES.length());
                    childDependency.setGroupId(lineWithoutSpaces.substring(0, lineWithoutSpaces.indexOf(Constants.WHITESPACE)));
                    childDependency.setChildren(collectChildrenDependencies(childDependency, groupLines));
                    // prevent adding dependencies without sha1 or artifact id version and dependency type.
                    if(dependency.getSha1() == null && dependency.getArtifactId() == null) {
                        logger.warn(DEPENDECYERROR, dependency.getGroupId());
                    } else {
                        dependencies.add(childDependency);
                    }
                } else {
                    // move to the next dependency parent with its children
                    break;
                }
            }
        }
        return dependencies;
    }
699297
def get_params(self):
        
        params = Data.get_params(self)
        params.update(BaseGraph.get_params(self))
        return params
575669
def resolve_dependency_graph(self, target):
        
        targets = self.deep_dependendants(target)
        # print "deep dependants:", targets
        return sorted(targets,
                      cmp=lambda a, b:
                          1 if b in self.deep_dependendants(a) else
                          -1 if a in self.deep_dependendants(b) else
                          0)
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))
6287
def resolve_node(self, node=None, resolved=None, seen=None):
        
        if seen is None:
            seen = []
        if resolved is None:
            resolved = []
        if node is None:
            dependencies = sorted(self._nodes.keys())
        else:
            dependencies = self._nodes[node]
            seen.append(node)
        for dependency in dependencies:
            if dependency in resolved:
                continue
            if dependency in seen:
                raise Exception('Circular dependency %s > %s', str(node),
                                str(dependency))
            self.resolve_node(dependency, resolved, seen)
        if node is not None:
            resolved.append(node)
        return resolved
1294484
def ind_nodes(self):
        
        graph = self.graph

        dependent_nodes = set(
            node for dependents
            in graph.values() for node in dependents)
        return [node_ for node_ in graph if node_ not in dependent_nodes]
86000
def dependencies(self, deps_dict):
        
        try:
            import pygraphviz as pgv
        except ImportError:
            graph_easy, comma = "", ""
            if (self.image == "ascii" and
                    not os.path.isfile("/usr/bin/graph-easy")):
                comma = ","
                graph_easy = " graph-easy"
            print("Require 'pygraphviz{0}{1}': Install with 'slpkg -s sbo "
                  "pygraphviz{1}'".format(comma, graph_easy))
            raise SystemExit()
        if self.image != "ascii":
            self.check_file()
        try:
            G = pgv.AGraph(deps_dict)
            G.layout(prog="fdp")
            if self.image == "ascii":
                G.write("{0}.dot".format(self.image))
                self.graph_easy()
            G.draw(self.image)
        except IOError:
            raise SystemExit()
        if os.path.isfile(self.image):
            print("Graph image file '{0}' created".format(self.image))
        raise SystemExit()
118267
def dependencies(self) -> List[Dependency]:
        """"""
        dependencies_str = DB.get_hash_value(self.key, 'dependencies')
        dependencies = []
        for dependency in ast.literal_eval(dependencies_str):
            dependencies.append(Dependency(dependency))
        return dependencies