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)