Get all repositories list from project
        :param project_key:
        :return:
342095
def repo_all_list(self, project_key):
        
        url = 'rest/api/1.0/projects/{projectKey}/repos'.format(projectKey=project_key)
        params = {}
        start = 0
        params['start'] = start
        response = self.get(url, params=params)
        if 'values' not in response:
            return []
        repo_list = (response or {}).get('values')
        while not response.get('isLastPage'):
            start = response.get('nextPageStart')
            params['start'] = start
            response = self.get(url, params=params)
            repo_list += (response or {}).get('values')
        return repo_list
749449
def get_repos(path):
    
    p = str(path)
    ret = []
    if not os.path.exists(p):
        return ret
    for d in os.listdir(p):
        pd = os.path.join(p, d)
        if os.path.exists(pd) and is_repo(pd):
            ret.append(Local(pd))
    return ret
604166
def list_projects(self):
        
        data = self._run(
            url_path="projects/list"
        )
        projects = data['result'].get('projects', [])
        return [self._project_formatter(item) for item in projects]
1079511
def list_projects(self, ignore_default_project_node=True):
        

        return [project_node.path for project_node in self.list_project_nodes(ignore_default_project_node) if
                project_node.path]
236007
def list_projects(self):
        
        url = self._build_url(constants.LIST_PROJECTS_ENDPOINT)
        json = self.client.get(url, timeout=self.timeout)
        return json['projects']
181991
def list(self, request):
        
        pipeline = [{'$match': request.args.pop('match', {})}]

        sort = request.args.pop('sort', {})
        if sort:
            pipeline.append({'$sort': sort})

        project = request.args.pop('project', {})
        if project:
            pipeline.append({'$project': project})

        return Response(serialize(self.collection.aggregate(pipeline)))
924580
def get_keys(self):
        
        return github.PaginatedList.PaginatedList(
            github.RepositoryKey.RepositoryKey,
            self._requester,
            self.url + "/keys",
            None
        )
1249534
def _repo_list(self, args):
        '''
        
        '''
        repo_metadata = self._get_repo_metadata()
        for repo in repo_metadata:
            self.ui.status(repo)
1259674
public List<GitlabSSHKey> getDeployKeys(Integer targetProjectId) throws IOException {
        String tailUrl = GitlabProject.URL + "/" + targetProjectId + GitlabSSHKey.DEPLOY_KEYS_URL;
        return Arrays.asList(retrieve().to(tailUrl, GitlabSSHKey[].class));
    }
559317
def repositories(self):
        
        if self.repo == "sbo":
            self.sbo_case_insensitive()
            self.find_pkg = sbo_search_pkg(self.name)
            if self.find_pkg:
                self.dependencies_list = Requires(self.flag).sbo(self.name)
        else:
            PACKAGES_TXT = Utils().read_file(
                self.meta.lib_path + "{0}_repo/PACKAGES.TXT".format(self.repo))
            self.names = Utils().package_name(PACKAGES_TXT)
            self.bin_case_insensitive()
            self.find_pkg = search_pkg(self.name, self.repo)
            if self.find_pkg:
                self.black = BlackList().packages(self.names, self.repo)
                self.dependencies_list = Dependencies(
                    self.repo, self.black).binary(self.name, self.flag)
175431
def list_files(self, project):
        
        path = "/projects/{}/files".format(project.id)
        res = yield from self.http_query("GET", path, timeout=120)
        return res.json
1157383
def get_repo_keys():
    '''
    
    '''
    ret = dict()
    repo_keys = list()

    # The double usage of '--with-fingerprint' is necessary in order to
    # retrieve the fingerprint of the subkey.
    cmd = ['apt-key', 'adv', '--batch', '--list-public-keys', '--with-fingerprint',
           '--with-fingerprint', '--with-colons', '--fixed-list-mode']

    cmd_ret = _call_apt(cmd, scope=False)

    if cmd_ret['retcode'] != 0:
        log.error(cmd_ret['stderr'])
        return ret

    lines = [line for line in cmd_ret['stdout'].splitlines() if line.strip()]

    # Reference for the meaning of each item in the colon-separated
    # record can be found here: https://goo.gl/KIZbvp
    for line in lines:
        items = [_convert_if_int(item.strip()) if item.strip() else None for item in line.split(':')]
        key_props = dict()

        if len(items) < 2:
            log.debug('Skipping line: %s', line)
            continue

        if items[0] in ('pub', 'sub'):
            key_props.update({
                'algorithm': items[3],
                'bits': items[2],
                'capability': items[11],
                'date_creation': items[5],
                'date_expiration': items[6],
                'keyid': items[4],
                'validity': items[1]
            })

            if items[0] == 'pub':
                repo_keys.append(key_props)
            else:
                repo_keys[-1]['subkey'] = key_props
        elif items[0] == 'fpr':
            if repo_keys[-1].get('subkey', False):
                repo_keys[-1]['subkey'].update({'fingerprint': items[9]})
            else:
                repo_keys[-1].update({'fingerprint': items[9]})
        elif items[0] == 'uid':
            repo_keys[-1].update({
                'uid': items[9],
                'uid_hash': items[7]
            })

    for repo_key in repo_keys:
        ret[repo_key['keyid']] = repo_key
    return ret
841232
public String retrieveReferenceList()
    {
        try 
        {
            references = gpUtil.getReferences(spaceKey, getPage().getTitle());
            if(isEditMode)
            {
                repositories = gpUtil.getRepositories(spaceKey);
                if(repositories.isEmpty())
                    throw new GreenPepperServerException("greenpepper.server.repositoriesnotfound", "");
                
                projectSystemUnderTests = gpUtil.getSystemsUnderTests(spaceKey);
                if(projectSystemUnderTests.isEmpty())
                    throw new GreenPepperServerException("greenpepper.server.sutsnotfound", "");
            }
        } 
        catch (GreenPepperServerException e) 
        {
            addActionError(e.getId());
            isEditMode = false;
        }

        return SUCCESS;
    }
264908
def get_projects(machine):
    

    query = Project.active.all()
    return [x.pid for x in query]
1120105
@SuppressWarnings("unchecked")
    public <REPO extends I_CmsRepository> List<REPO> getRepositories(Class<REPO> cls) {

        List<REPO> result = new ArrayList<REPO>();
        for (I_CmsRepository repo : m_repositoryMap.values()) {
            if (cls.isInstance(repo)) {
                result.add((REPO)repo);
            }
        }
        return result;
    }
1083327
def get_unique_repositories(repo_list):
        
        unique_list = list()
        included = defaultdict(lambda: False)
        for repo in repo_list:
            if not included[repo.full_name]:
                unique_list.append(repo)
                included[repo.full_name] = True
        return unique_list
815378
def get_snapshots(self,**kwargs):
        
        commits = self.repository.get_commits(**kwargs)
        snapshots = []
        for commit in commits:
            for key in ('committer_date','author_date'):
                commit[key] = datetime.datetime.fromtimestamp(commit[key+'_ts'])
            snapshot = GitSnapshot(commit)
            hasher = Hasher()
            hasher.add(snapshot.sha)
            snapshot.hash = hasher.digest.hexdigest()
            snapshot.project = self.project
            snapshot.pk = uuid.uuid4().hex
            snapshots.append(snapshot)
        return snapshots