before send to remote

env/lib/python3.8/site-packages/django/contrib/gis/sitemaps/__init__.py

@@ -0,0 +1,4 @@
+# Geo-enabled Sitemap classes.
+from django.contrib.gis.sitemaps.kml import KMLSitemap, KMZSitemap
+
+__all__ = ["KMLSitemap", "KMZSitemap"]

env/lib/python3.8/site-packages/django/contrib/gis/sitemaps/kml.py

@@ -0,0 +1,78 @@
+from django.apps import apps
+from django.contrib.gis.db.models import GeometryField
+from django.contrib.sitemaps import Sitemap
+from django.db import models
+from django.urls import reverse
+
+
+class KMLSitemap(Sitemap):
+    """
+    A minimal hook to produce KML sitemaps.
+    """
+
+    geo_format = "kml"
+
+    def __init__(self, locations=None):
+        # If no locations specified, then we try to build for
+        # every model in installed applications.
+        self.locations = self._build_kml_sources(locations)
+
+    def _build_kml_sources(self, sources):
+        """
+        Go through the given sources and return a 3-tuple of the application
+        label, module name, and field name of every GeometryField encountered
+        in the sources.
+
+        If no sources are provided, then all models.
+        """
+        kml_sources = []
+        if sources is None:
+            sources = apps.get_models()
+        for source in sources:
+            if isinstance(source, models.base.ModelBase):
+                for field in source._meta.fields:
+                    if isinstance(field, GeometryField):
+                        kml_sources.append(
+                            (
+                                source._meta.app_label,
+                                source._meta.model_name,
+                                field.name,
+                            )
+                        )
+            elif isinstance(source, (list, tuple)):
+                if len(source) != 3:
+                    raise ValueError(
+                        "Must specify a 3-tuple of (app_label, module_name, "
+                        "field_name)."
+                    )
+                kml_sources.append(source)
+            else:
+                raise TypeError("KML Sources must be a model or a 3-tuple.")
+        return kml_sources
+
+    def get_urls(self, page=1, site=None, protocol=None):
+        """
+        This method is overridden so the appropriate `geo_format` attribute
+        is placed on each URL element.
+        """
+        urls = Sitemap.get_urls(self, page=page, site=site, protocol=protocol)
+        for url in urls:
+            url["geo_format"] = self.geo_format
+        return urls
+
+    def items(self):
+        return self.locations
+
+    def location(self, obj):
+        return reverse(
+            "django.contrib.gis.sitemaps.views.%s" % self.geo_format,
+            kwargs={
+                "label": obj[0],
+                "model": obj[1],
+                "field_name": obj[2],
+            },
+        )
+
+
+class KMZSitemap(KMLSitemap):
+    geo_format = "kmz"

env/lib/python3.8/site-packages/django/contrib/gis/sitemaps/views.py

@@ -0,0 +1,65 @@
+from django.apps import apps
+from django.contrib.gis.db.models import GeometryField
+from django.contrib.gis.db.models.functions import AsKML, Transform
+from django.contrib.gis.shortcuts import render_to_kml, render_to_kmz
+from django.core.exceptions import FieldDoesNotExist
+from django.db import DEFAULT_DB_ALIAS, connections
+from django.http import Http404
+
+
+def kml(request, label, model, field_name=None, compress=False, using=DEFAULT_DB_ALIAS):
+    """
+    This view generates KML for the given app label, model, and field name.
+
+    The field name must be that of a geographic field.
+    """
+    placemarks = []
+    try:
+        klass = apps.get_model(label, model)
+    except LookupError:
+        raise Http404(
+            'You must supply a valid app label and module name.  Got "%s.%s"'
+            % (label, model)
+        )
+
+    if field_name:
+        try:
+            field = klass._meta.get_field(field_name)
+            if not isinstance(field, GeometryField):
+                raise FieldDoesNotExist
+        except FieldDoesNotExist:
+            raise Http404("Invalid geometry field.")
+
+    connection = connections[using]
+
+    if connection.features.has_AsKML_function:
+        # Database will take care of transformation.
+        placemarks = klass._default_manager.using(using).annotate(kml=AsKML(field_name))
+    else:
+        # If the database offers no KML method, we use the `kml`
+        # attribute of the lazy geometry instead.
+        placemarks = []
+        if connection.features.has_Transform_function:
+            qs = klass._default_manager.using(using).annotate(
+                **{"%s_4326" % field_name: Transform(field_name, 4326)}
+            )
+            field_name += "_4326"
+        else:
+            qs = klass._default_manager.using(using).all()
+        for mod in qs:
+            mod.kml = getattr(mod, field_name).kml
+            placemarks.append(mod)
+
+    # Getting the render function and rendering to the correct.
+    if compress:
+        render = render_to_kmz
+    else:
+        render = render_to_kml
+    return render("gis/kml/placemarks.kml", {"places": placemarks})
+
+
+def kmz(request, label, model, field_name=None, using=DEFAULT_DB_ALIAS):
+    """
+    Return KMZ for the given app label, model, and field name.
+    """
+    return kml(request, label, model, field_name, compress=True, using=using)