List of remote repositories to resolve artifacts from.
421416
@Provides @Singleton
    public List<RemoteRepository> getRemoteRepositories(
            SettingsDecrypter decrypter,
            ExtensionList<RemoteRepositoryDecorator> decorators) {

        List<RemoteRepository> repositories = new ArrayList<RemoteRepository>();
        MavenDependencyResolverSettings resolverSettings = new MavenDependencyResolverSettings();
        resolverSettings.setUseMavenCentral(true);
        List<RemoteRepository> repos = resolverSettings.getRemoteRepositories();
        for (RemoteRepository remoteRepository : repos) {
            Server server = resolverSettings.getSettings().getServer(remoteRepository.getId());
            if (server != null) {
                server = decrypter.decrypt(new DefaultSettingsDecryptionRequest(server)).getServer();
                remoteRepository.setAuthentication(new Authentication(server.getUsername(), server.getPassword(), server.getPrivateKey(), server.getPassphrase()));
            }
            repositories.add(decorate(remoteRepository, decorators));
        }
        RemoteRepository r = new RemoteRepository("cloudbees-public-release", "default", "https://repository-cloudbees.forge.cloudbees.com/public-release/");
        repositories.add(decorate(r,decorators));
        return repositories;
    }
835488
public ArtifactResult resolveArtifact( Artifact artifact ) throws ArtifactResolutionException {
        return resolveArtifact(new ArtifactRequest(artifact,remoteRepositories,null));
    }
759369
def installed_list(cls):
        
        logger.debug("")

        res = []
        for x in repo_dirlist():
            d = x['path']
            try:
                res.append(Repo(repo_dir=d, name=x['base']))
            except InvalidRepo:
                logger.warning("Invalid repo '%s' in the installation directory.", d)

        return res
1210401
@Override
    public File resolveArtifact(String coordinates) throws ArtifactException
    {
        ArtifactRequest request = new ArtifactRequest();
        Artifact artifact = new DefaultArtifact(coordinates);
        request.setArtifact(artifact);
        request.setRepositories(remoteRepositories);

        log.debug(String.format("Resolving artifact %s from %s", artifact, remoteRepositories));

        ArtifactResult result;
        try
        {
            result = repositorySystem.resolveArtifact(repositorySession, request);
        }
        catch (ArtifactResolutionException e)
        {
            throw new ArtifactException(e.getMessage(), e);
        }

        log.debug(String.format("Resolved artifact %s to %s from %s",
                artifact,
                result.getArtifact().getFile(),
                result.getRepository()));

        return result.getArtifact().getFile();
    }
421249
def dependencies(project_name):
    """"""
    log = logging.getLogger('ciu')
    log.info('Locating dependencies for {}'.format(project_name))
    located = distlib.locators.locate(project_name, prereleases=True)
    if not located:
        log.warning('{0} not found'.format(project_name))
        return None
    return {packaging.utils.canonicalize_name(pypi.just_name(dep))
            for dep in located.run_requires}
437530
def update_repositories(repositories, conf_path):
    
    repo_file = "{0}custom-repositories".format(conf_path)
    if os.path.isfile(repo_file):
        f = open(repo_file, "r")
        repositories_list = f.read()
        f.close()
        for line in repositories_list.splitlines():
            line = line.lstrip()
            if line and not line.startswith("#"):
                repositories.append(line.split()[0])
    return repositories
611125
def artifact_bundles(self):
        
        if not self.__artifact_bundles:
            self.__artifact_bundles = ArtifactBundles(self.__connection)
        return self.__artifact_bundles
964502
def resolve(checks, lazy, quiet):
    
    root = get_root()
    if 'all' in checks:
        checks = os.listdir(root)

    for check_name in sorted(checks):
        pinned_reqs_file = os.path.join(root, check_name, 'requirements.in')
        resolved_reqs_file = os.path.join(root, check_name, 'requirements.txt')

        if os.path.isfile(pinned_reqs_file):
            if not quiet:
                echo_info('Check `{}`:'.format(check_name))

            if not quiet:
                echo_waiting('    Resolving dependencies...')

            pre_packages = read_packages(resolved_reqs_file)
            result = resolve_requirements(pinned_reqs_file, resolved_reqs_file, lazy=lazy)
            if result.code:
                abort(result.stdout + result.stderr)

            if not quiet:
                post_packages = read_packages(resolved_reqs_file)
                display_package_changes(pre_packages, post_packages, indent='    ')
298628
def refs(self):
        
        out_refs = IterableList(RemoteReference._id_attribute_, "%s/" % self.name)
        out_refs.extend(RemoteReference.list_items(self.repo, remote=self.name))
        return out_refs
585836
public List<String> getRemoteRepositoryUrls() {
        List<String> urls = new ArrayList<String>();
        for( RemoteRepository repo : getRemoteRepositories() ) {
            urls.add( repo.getUrl() );
        }
        
        return urls;
    }
1229289
def get_repos(self):
        
        url_parameters = dict()

        return github.PaginatedList.PaginatedList(
            contentClass=github.Repository.Repository,
            requester=self._requester,
            firstUrl="/installation/repositories",
            firstParams=url_parameters,
            headers=INTEGRATION_PREVIEW_HEADERS,
            list_item='repositories'
        )
1312788
private Map<Environment, Collection<ArtifactIdentifier>> getArtifactIdentifiers(List<Environment> environments) {
		Map<Environment, Collection<ArtifactIdentifier>> rt = new HashMap<>();
		
		for (Environment env : environments) {
			Set<ArtifactIdentifier> ids = new HashSet<>();
			
			if (env.getUnits() != null) {
				for (DeployableUnit du : env.getUnits()) {
			        String artifactName = du.getName();
			        String artifactExtension = null;
			        int dotIdx = artifactName.lastIndexOf('.');
			        if (dotIdx > 0) {
			        	// If idx is 0 starts with a dot... in which case not an extension
			        	
			        	artifactName = artifactName.substring(0, dotIdx);
			        	artifactExtension = artifactName.substring(dotIdx);
			        }
					
					ArtifactIdentifier id = new ArtifactIdentifier(null, artifactName, du.getVersion(), null, artifactExtension);
					
					ids.add(id);
				}
			}
			
			rt.put(env, new ArrayList<>(ids));
		}
		
		return rt;
	}
179857
def custom_repository(self):
        
        custom_dict_repo = {}
        for line in self.custom_repositories_list.splitlines():
            line = line.lstrip()
            if not line.startswith("#"):
                custom_dict_repo[line.split()[0]] = line.split()[1]
        return custom_dict_repo
865781
def find_repositories_by_walking_without_following_symlinks(path):
    """"""
    repos = []
    for dirpath, dirnames, filenames in os.walk(path, followlinks=False):
        for dotdir in set(dirnames) & DOTDIRS:
            repos.append((dirpath, dotdir))
    return repos
996730
def artifact_cache_dir(self):
    """"""
    return (self.get_options().artifact_cache_dir or
            os.path.join(self.scratch_dir, 'artifacts'))
442176
private static function _getRemoteRepositories()
	{
		self::_init();
		if (!self::$remoteRepositories)
		{
			self::$remoteRepositories = self::_getRepositoryManager()->getRepositories();
		}
		return self::$remoteRepositories;
	}
642152
def list_repos(**kwargs):
    '''
    
    '''
    _check_apt()
    repos = {}
    sources = sourceslist.SourcesList()
    for source in sources.list:
        if _skip_source(source):
            continue
        repo = {}
        repo['file'] = source.file
        repo['comps'] = getattr(source, 'comps', [])
        repo['disabled'] = source.disabled
        repo['enabled'] = not repo['disabled']  # This is for compatibility with the other modules
        repo['dist'] = source.dist
        repo['type'] = source.type
        repo['uri'] = source.uri.rstrip('/')
        repo['line'] = salt.utils.pkg.deb.strip_uri(source.line.strip())
        repo['architectures'] = getattr(source, 'architectures', [])
        repos.setdefault(source.uri, []).append(repo)
    return repos