fetches all releases also finds releases corresponding to provided tags
500414
async function getReleaseInfo(context, childTags) {
  const tagShas = [];

  const releasesBySha = await fetchAllReleases(context, release => {
    if (childTags.has(release.tag_name)) {
      // put in reverse order
      // later releases come first,
      // but we want to iterate beginning oldest releases first
      tagShas.unshift(release.target_commitish);
      // tagSha.push(release.target_commitish);
    }
  });

  return {releasesBySha, tagShas};
}
679102
def get_release(self, id):
        
        if isinstance(id, int):
            headers, data = self._requester.requestJsonAndCheck(
                "GET",
                self.url + "/releases/" + str(id)
            )
            return github.GitRelease.GitRelease(self._requester, headers, data, completed=True)
        elif isinstance(id, (str, unicode)):
            headers, data = self._requester.requestJsonAndCheck(
                "GET",
                self.url + "/releases/tags/" + id
            )
            return github.GitRelease.GitRelease(self._requester, headers, data, completed=True)
737082
def get_releases(self):
        
        return github.PaginatedList.PaginatedList(
            github.GitRelease.GitRelease,
            self._requester,
            self.url + "/releases",
            None
        )
1214321
def find_output_with_tag(self, tag):
        
        # Enforce upper case
        tag = tag.upper()
        return FileList([i for i in self if tag in i.tags])
275949
def parse_changes():
    

    with open('CHANGES') as changes:
        for match in re.finditer(RE_CHANGES, changes.read(1024), re.M):
            if len(match.group(1)) != len(match.group(3)):
                error('incorrect underline in CHANGES')

            date = datetime.datetime.strptime(match.group(4),
                                              '%Y-%m-%d').date()

            if date != datetime.date.today():
                error('release date is not today')

            return match.group(2)

    error('invalid release entry in CHANGES')
677665
def package_releases(self, package, url_fmt=lambda u: u):
        
        return [{
            'name': package,
            'version': version,
            'urls': [self.get_urlhash(f, url_fmt) for f in files]
        } for version, files in self.storage.get(package, {}).items()]
100287
def get_previous_version(self):
        """"""
        gh = self.get_github_api()
        repo = gh.repository(self.repo_owner, self.repo_name)
        most_recent = None
        for release in repo.releases():
            # Return the second release that matches the release prefix
            if release.tag_name.startswith(self.project__git__prefix_release):
                if most_recent is None:
                    most_recent = release
                else:
                    return LooseVersion(self.get_version_for_tag(release.tag_name))
737205
function getNewVersions() {
  return getTags()
    .then(tags => {
      var newVersions = []
      for(tag of tags) {
        if (semver.gt(tag.name, update.latest) || (
            semver.eq(tag.name, update.latest) && (semver(tag.name).build[0] || 0) > (semver(update.latest).build[0] || 0)
          )) {
          newVersions.push(tag)
        }
      }
      newVersions.reverse()
      // order versions from lower to greater
      console.log(chalk.blue('New versions available: ' + (newVersions.map(v => v.name).join(', ') || 'none') + '.'))
      return newVersions
    })
    .catch(e => console.log(e.stack))
}
64628
def fetch_releases(self, package_name):
        """"""
        package_name = self.source.normalize_package_name(package_name)
        releases = self.source.get_package_versions(package_name)
        releases_with_index_url = [(item, self.index_url) for item in releases]
        return package_name, releases_with_index_url
305604
def find_tags(self):
        """"""
        listing = self.context.capture('git', 'show-ref', '--tags', check=False)
        for line in listing.splitlines():
            tokens = line.split()
            if len(tokens) >= 2 and tokens[1].startswith('refs/tags/'):
                yield Revision(
                    repository=self,
                    revision_id=tokens[0],
                    tag=tokens[1][len('refs/tags/'):],
                )
691320
def query_versions(self, version=None):
        """"""
        if version not in RELEASE_AND_CANDIDATE_LATEST_VERSIONS:
            return [version]

        url = urljoin(self.base_url, 'releases/')
        parser = self._create_directory_parser(url)
        if version:
            versions = parser.filter(RELEASE_AND_CANDIDATE_LATEST_VERSIONS[version])
            from distutils.version import LooseVersion
            versions.sort(key=LooseVersion)
            return [versions[-1]]
        else:
            return parser.entries
1031661
def tags_all(self):
        
        if 'tags' not in self.database.collection_names():
            print 'Warning: Searching on non-existance tags collection'
            return None

        cursor = self.database['tags'].find({}, {'_id':0, 'md5':1, 'tags':1})
        return [item for item in cursor]
197470
def parse(name, content, releases, get_head_fn):
    
    try:
        return {e["version"]: e["changelog"] for e in content["entries"]
                if e["changelog"]}
    except KeyError:
        return {}
1236064
def all_versions(req):
    """"""
    import requests
    url = "https://pypi.python.org/pypi/" + req + "/json"
    return tuple(requests.get(url).json()["releases"].keys())
750135
public function getReleaseByTagName(string $tag): array
    {
        return $this->getApi()->request($this->getApi()->sprintf('/repos/:owner/:repo/releases/tags/:tag',
            $this->getRepositories()->getOwner(), $this->getRepositories()->getRepo(), $tag));
    }
1324252
def version_downloads(self):
        """"""
        ret = OrderedDict()
        for release, info in self.release_info:
            download_count = sum(file_['downloads'] for file_ in info)
            ret[release] = download_count
        return ret
1296095
def get_tagged_albums(self, tag, limit=None, cacheable=True):
        """"""

        params = self._get_params()
        params["tag"] = tag
        params["taggingtype"] = "album"
        if limit:
            params["limit"] = limit
        doc = self._request(self.ws_prefix + ".getpersonaltags", cacheable, params)
        return _extract_albums(doc, self.network)