before send to remote

env/lib/python3.8/site-packages/django/contrib/gis/management/commands/inspectdb.py

@@ -0,0 +1,18 @@
+from django.core.management.commands.inspectdb import Command as InspectDBCommand
+
+
+class Command(InspectDBCommand):
+    db_module = "django.contrib.gis.db"
+
+    def get_field_type(self, connection, table_name, row):
+        field_type, field_params, field_notes = super().get_field_type(
+            connection, table_name, row
+        )
+        if field_type == "GeometryField":
+            # Getting a more specific field type and any additional parameters
+            # from the `get_geometry_type` routine for the spatial backend.
+            field_type, geo_params = connection.introspection.get_geometry_type(
+                table_name, row
+            )
+            field_params.update(geo_params)
+        return field_type, field_params, field_notes

env/lib/python3.8/site-packages/django/contrib/gis/management/commands/ogrinspect.py

@@ -0,0 +1,164 @@
+import argparse
+
+from django.contrib.gis import gdal
+from django.core.management.base import BaseCommand, CommandError
+from django.utils.inspect import get_func_args
+
+
+class LayerOptionAction(argparse.Action):
+    """
+    Custom argparse action for the `ogrinspect` `layer_key` keyword option
+    which may be an integer or a string.
+    """
+
+    def __call__(self, parser, namespace, value, option_string=None):
+        try:
+            setattr(namespace, self.dest, int(value))
+        except ValueError:
+            setattr(namespace, self.dest, value)
+
+
+class ListOptionAction(argparse.Action):
+    """
+    Custom argparse action for `ogrinspect` keywords that require
+    a string list. If the string is 'True'/'true' then the option
+    value will be a boolean instead.
+    """
+
+    def __call__(self, parser, namespace, value, option_string=None):
+        if value.lower() == "true":
+            setattr(namespace, self.dest, True)
+        else:
+            setattr(namespace, self.dest, value.split(","))
+
+
+class Command(BaseCommand):
+    help = (
+        "Inspects the given OGR-compatible data source (e.g., a shapefile) and "
+        "outputs\na GeoDjango model with the given model name. For example:\n"
+        " ./manage.py ogrinspect zipcode.shp Zipcode"
+    )
+
+    requires_system_checks = []
+
+    def add_arguments(self, parser):
+        parser.add_argument("data_source", help="Path to the data source.")
+        parser.add_argument("model_name", help="Name of the model to create.")
+        parser.add_argument(
+            "--blank",
+            action=ListOptionAction,
+            default=False,
+            help="Use a comma separated list of OGR field names to add "
+            "the `blank=True` option to the field definition. Set to `true` "
+            "to apply to all applicable fields.",
+        )
+        parser.add_argument(
+            "--decimal",
+            action=ListOptionAction,
+            default=False,
+            help="Use a comma separated list of OGR float fields to "
+            "generate `DecimalField` instead of the default "
+            "`FloatField`. Set to `true` to apply to all OGR float fields.",
+        )
+        parser.add_argument(
+            "--geom-name",
+            default="geom",
+            help="Specifies the model name for the Geometry Field (defaults to `geom`)",
+        )
+        parser.add_argument(
+            "--layer",
+            dest="layer_key",
+            action=LayerOptionAction,
+            default=0,
+            help="The key for specifying which layer in the OGR data "
+            "source to use. Defaults to 0 (the first layer). May be "
+            "an integer or a string identifier for the layer.",
+        )
+        parser.add_argument(
+            "--multi-geom",
+            action="store_true",
+            help="Treat the geometry in the data source as a geometry collection.",
+        )
+        parser.add_argument(
+            "--name-field",
+            help="Specifies a field name to return for the __str__() method.",
+        )
+        parser.add_argument(
+            "--no-imports",
+            action="store_false",
+            dest="imports",
+            help="Do not include `from django.contrib.gis.db import models` statement.",
+        )
+        parser.add_argument(
+            "--null",
+            action=ListOptionAction,
+            default=False,
+            help="Use a comma separated list of OGR field names to add "
+            "the `null=True` option to the field definition. Set to `true` "
+            "to apply to all applicable fields.",
+        )
+        parser.add_argument(
+            "--srid",
+            help="The SRID to use for the Geometry Field. If it can be "
+            "determined, the SRID of the data source is used.",
+        )
+        parser.add_argument(
+            "--mapping",
+            action="store_true",
+            help="Generate mapping dictionary for use with `LayerMapping`.",
+        )
+
+    def handle(self, *args, **options):
+        data_source, model_name = options.pop("data_source"), options.pop("model_name")
+
+        # Getting the OGR DataSource from the string parameter.
+        try:
+            ds = gdal.DataSource(data_source)
+        except gdal.GDALException as msg:
+            raise CommandError(msg)
+
+        # Returning the output of ogrinspect with the given arguments
+        # and options.
+        from django.contrib.gis.utils.ogrinspect import _ogrinspect, mapping
+
+        # Filter options to params accepted by `_ogrinspect`
+        ogr_options = {
+            k: v
+            for k, v in options.items()
+            if k in get_func_args(_ogrinspect) and v is not None
+        }
+        output = [s for s in _ogrinspect(ds, model_name, **ogr_options)]
+
+        if options["mapping"]:
+            # Constructing the keyword arguments for `mapping`, and
+            # calling it on the data source.
+            kwargs = {
+                "geom_name": options["geom_name"],
+                "layer_key": options["layer_key"],
+                "multi_geom": options["multi_geom"],
+            }
+            mapping_dict = mapping(ds, **kwargs)
+            # This extra legwork is so that the dictionary definition comes
+            # out in the same order as the fields in the model definition.
+            rev_mapping = {v: k for k, v in mapping_dict.items()}
+            output.extend(
+                [
+                    "",
+                    "",
+                    "# Auto-generated `LayerMapping` dictionary for %s model"
+                    % model_name,
+                    "%s_mapping = {" % model_name.lower(),
+                ]
+            )
+            output.extend(
+                "    '%s': '%s'," % (rev_mapping[ogr_fld], ogr_fld)
+                for ogr_fld in ds[options["layer_key"]].fields
+            )
+            output.extend(
+                [
+                    "    '%s': '%s',"
+                    % (options["geom_name"], mapping_dict[options["geom_name"]]),
+                    "}",
+                ]
+            )
+        return "\n".join(output)