def api_versions(self):
     ret = []
     for version_data in api.version.get(project=self.pk,
                                         active=True)['objects']:
         version = make_api_version(version_data)
         ret.append(version)
     return sort_version_aware(ret)

 def api_versions(self):
     from readthedocs.builds.models import Version
     ret = []
     for version_data in api.version.get(project=self.pk, active=True)['objects']:
         version = make_api_version(version_data)
         ret.append(version)
     return sort_version_aware(ret)

 def api_versions(self):
     from readthedocs.builds.models import APIVersion
     ret = []
     for version_data in api.project(self.pk).active_versions.get()['versions']:
         version = APIVersion(**version_data)
         ret.append(version)
     return sort_version_aware(ret)

    def ordered_active_versions(self, user=None):
        from readthedocs.builds.models import Version

        kwargs = {"project": self, "only_active": True}
        if user:
            kwargs["user"] = user
        versions = Version.objects.public(**kwargs)
        return sort_version_aware(versions)

    def get_all_active_versions(self):
        """
        Returns all active versions.

        Returns a smartly sorted list of tuples.
        First item of each tuple is the version's slug,
        and the second item is version's verbose_name.
        """
        version_qs = self.instance.all_active_versions()
        if version_qs.exists():
            version_qs = sort_version_aware(version_qs)
            all_versions = [(version.slug, version.verbose_name) for version in version_qs]
            return all_versions
        return None

 def ordered_active_versions(self, user=None):
     from readthedocs.builds.models import Version
     kwargs = {
         'project': self,
         'only_active': True,
     }
     if user:
         kwargs['user'] = user
     versions = Version.objects.public(**kwargs).select_related(
         'project',
         'project__main_language_project',
     ).prefetch_related(
         Prefetch(
             'project__superprojects',
             ProjectRelationship.objects.all().select_related('parent'),
             to_attr='_superprojects',
         ),
         Prefetch(
             'project__domains',
             Domain.objects.filter(canonical=True),
             to_attr='_canonical_domains',
         ),
     )
     return sort_version_aware(versions)

def project_downloads(request, project_slug):
    """A detail view for a project with various downloads."""
    project = get_object_or_404(
        Project.objects.protected(request.user),
        slug=project_slug,
    )
    versions = Version.objects.public(user=request.user, project=project)
    versions = sort_version_aware(versions)
    version_data = OrderedDict()
    for version in versions:
        data = version.get_downloads()
        # Don't show ones that have no downloads.
        if data:
            version_data[version] = data

    return render(
        request,
        'projects/project_downloads.html',
        {
            'project': project,
            'version_data': version_data,
            'versions': versions,
        },
    )

 def ordered_active_versions(self):
     from readthedocs.builds.models import Version
     versions = Version.objects.public(project=self, only_active=True)
     return sort_version_aware(versions)

def sitemap_xml(request, project):
    """
    Generate and serve a ``sitemap.xml`` for a particular ``project``.

    The sitemap is generated from all the ``active`` and public versions of
    ``project``. These versions are sorted by using semantic versioning
    prepending ``latest`` and ``stable`` (if they are enabled) at the beginning.

    Following this order, the versions are assigned priorities and change
    frequency. Starting from 1 and decreasing by 0.1 for priorities and starting
    from daily, weekly to monthly for change frequency.

    If the project is private, the view raises ``Http404``. On the other hand,
    if the project is public but a version is private, this one is not included
    in the sitemap.

    :param request: Django request object
    :param project: Project instance to generate the sitemap

    :returns: response with the ``sitemap.xml`` template rendered

    :rtype: django.http.HttpResponse
    """

    def priorities_generator():
        """
        Generator returning ``priority`` needed by sitemap.xml.

        It generates values from 1 to 0.1 by decreasing in 0.1 on each
        iteration. After 0.1 is reached, it will keep returning 0.1.
        """
        priorities = [1, 0.9, 0.8, 0.7, 0.6, 0.5, 0.4, 0.3, 0.2]
        yield from itertools.chain(priorities, itertools.repeat(0.1))

    def changefreqs_generator():
        """
        Generator returning ``changefreq`` needed by sitemap.xml.

        It returns ``daily`` on first iteration, then ``weekly`` and then it
        will return always ``monthly``.

        We are using ``monthly`` as last value because ``never`` is too
        aggressive. If the tag is removed and a branch is created with the same
        name, we will want bots to revisit this.
        """
        changefreqs = ['daily', 'weekly']
        yield from itertools.chain(changefreqs, itertools.repeat('monthly'))

    if project.privacy_level == constants.PRIVATE:
        raise Http404

    sorted_versions = sort_version_aware(
        Version.objects.public(
            project=project,
            only_active=True,
        ),
    )
    versions = []
    for version, priority, changefreq in zip(
            sorted_versions,
            priorities_generator(),
            changefreqs_generator(),
    ):
        element = {
            'loc': version.get_subdomain_url(),
            'priority': priority,
            'changefreq': changefreq,
            'languages': [],
        }

        # Version can be enabled, but not ``built`` yet. We want to show the
        # link without a ``lastmod`` attribute
        last_build = version.builds.order_by('-date').first()
        if last_build:
            element['lastmod'] = last_build.date.isoformat()

        if project.translations.exists():
            for translation in project.translations.all():
                translation_versions = translation.versions.public(
                    ).values_list('slug', flat=True)
                if version.slug in translation_versions:
                    href = project.get_docs_url(
                        version_slug=version.slug,
                        lang_slug=translation.language,
                        private=False,
                    )
                    element['languages'].append({
                        'hreflang': translation.language,
                        'href': href,
                    })

            # Add itself also as protocol requires
            element['languages'].append({
                'hreflang': project.language,
                'href': element['loc'],
            })

        versions.append(element)

    context = {
#.........这里部分代码省略.........

 def ordered_active_versions(self):
     return sort_version_aware(self.versions.filter(active=True))