Add a dep and store it in the self.deps

        :returns: None
        :rtype: None
        :raises: None
555069
def add_dep(self, ):
        
        i = self.dep_tablev.currentIndex()
        item = i.internalPointer()
        if item:
            dep = item.internal_data()
            dep.projects.add(self._project)
            self.deps.append(dep)
            item.set_parent(None)
1126302
def insert(self, context, plan):
	
		
		
		op = execution.Insert(self.__comp_name, self.__comp())
		if op not in plan and self.available(context) != True:
			for dep_stub in self.dependencies():
				dep_stub.insert(context, plan)
			plan.append(op)
338809
def store_records_for_package(self, entry_point, records):
        

        pkg_records_entry = self._dist_to_package_module_map(entry_point)
        pkg_records_entry.extend(
            rec for rec in records if rec not in pkg_records_entry)
        # TODO figure out a more efficient way to do this with a bit
        # more reuse.
        if entry_point.dist is not None:
            if entry_point.dist.project_name not in self.package_loader_map:
                self.package_loader_map[entry_point.dist.project_name] = []
            self.package_loader_map[entry_point.dist.project_name].append(
                entry_point.name)
856411
def add_project(self, ):
        
        i = self.prj_tablev.currentIndex()
        item = i.internalPointer()
        if item:
            project = item.internal_data()
            if self._atype:
                self._atype.projects.add(project)
            elif self._dep:
                self._dep.projects.add(project)
            else:
                project.users.add(self._user)
            self.projects.append(project)
            item.set_parent(None)
1007582
def add_dependency(id=None, name=None, dependency_id=None, dependency_name=None):
    
    data = add_dependency_raw(id, name, dependency_id, dependency_name)
    if data:
        return utils.format_json_list(data)
108990
def install_deps(pkgpath):
    
    if os.path.exists(os.path.join(pkgpath, "requirements.txt")):
        logger.debug("installing dependencies")
        click.secho("[*] Installing dependencies")
        pipargs = ["install", "--target", os.path.join(pkgpath, defs.DEPS_DIR), "--ignore-installed",
                   "-r", os.path.join(pkgpath, "requirements.txt")]
        logger.debug("running pip %s", pipargs)
        return subprocess.check_call([sys.executable, "-m", "pip"] + pipargs)
    return 0
1137686
def add(self, *args, **kwargs):
        
        return self._apply(operator.add, *args, **kwargs)
251263
def add(self, pkgs):
        
        blacklist = self.get_black()
        pkgs = set(pkgs)
        print("\nAdd packages in the blacklist:\n")
        with open(self.blackfile, "a") as black_conf:
            for pkg in pkgs:
                if pkg not in blacklist:
                    print("{0}{1}{2}".format(self.meta.color["GREEN"], pkg,
                                             self.meta.color["ENDC"]))
                    black_conf.write(pkg + "\n")
                    self.quit = True
            black_conf.close()
        if self.quit:
            print("")
573027
def _insert_defaults(self):
        
        merged = merge_defaults(self.structure, self)
        self.update(merged)
252393
def addSubprocess(self, fds, name, factory):
        
        self._lock.run(self._addSubprocess, self, fds, name, factory)
43786
def add_object(self, start, obj, object_size):
        

        self._store(start, obj, object_size, overwrite=False)
1304098
def _add_defaults_python(self):
        """"""
        if self.distribution.has_pure_modules():
            build_py = self.get_finalized_command('build_py')
            self.filelist.extend(build_py.get_source_files())
            # This functionality is incompatible with include_package_data, and
            # will in fact create an infinite recursion if include_package_data
            # is True.  Use of include_package_data will imply that
            # distutils-style automatic handling of package_data is disabled
            if not self.distribution.include_package_data:
                for _, src_dir, _, filenames in build_py.data_files:
                    self.filelist.extend([os.path.join(src_dir, filename)
                                          for filename in filenames])
89156
def prj_create_dep(self, *args, **kwargs):
        
        if not self.cur_prj:
            return
        dep = self.create_dep(projects=[self.cur_prj])
        if dep:
            depdata = djitemdata.DepartmentItemData(dep)
            treemodel.TreeItem(depdata, self.prj_dep_model.root)
195262
def add_dependency(self,my_dep):
        
        if self.dependency_layer is None:
            self.dependency_layer = Cdependencies()
            self.root.append(self.dependency_layer.get_node())
        self.dependency_layer.add_dependency(my_dep)
413038
def add_atype(self, ):
        
        i = self.atype_tablev.currentIndex()
        item = i.internalPointer()
        if item:
            atype = item.internal_data()
            atype.projects.add(self._project)
            self.atypes.append(atype)
            item.set_parent(None)
51877
def Add(self, artifact=None, target=None, callback=None):
    
    # Cases where a target field is undefined or empty need special handling.
    # Repeated field helper in target yields results, so expand this out into a
    # list. If the attribute doesn't exist, default to an empty list.
    # Then, in either case, replace the empty list with one containing a single
    # None value.
    if target is None:
      target = Target()
    os_name = target.Get("os") or [None]
    cpe = target.Get("cpe") or [None]
    label = target.Get("label") or [None]
    attributes = itertools.product(os_name, cpe, label)
    new_conditions = [Condition(artifact, *attr) for attr in attributes]
    self.conditions.update(new_conditions)
    self._Register(new_conditions, callback)
585162
public void addDependency(JSModule dep) {
    checkNotNull(dep);
    Preconditions.checkState(dep != this, "Cannot add dependency on self", this);
    deps.add(dep);
  }