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()}
def get_readonly_fields(self, request, obj=None):
args = get_func_args(self.has_add_permission)
if 'obj' in args:
has_add_permission = self.has_add_permission(request, obj)
else:
has_add_permission = self.has_add_permission(request)
if obj is None and has_add_permission:
return super().get_readonly_fields(request, obj)
if self.fields or self.fieldsets:
fields = flatten_fieldsets(self.get_fieldsets(request, obj))
else:
opts = self.model._meta
sortable_private_fields = [f for f in opts.private_fields if isinstance(f, Field)]
fields = [
field.name for field in
sorted(chain(opts.concrete_fields, sortable_private_fields, opts.many_to_many))
if field.editable and not field.auto_created
]
exclude = self.get_exclude(request, obj)
editable_fields = self.get_editable_fields(request, obj)
return [
field for field in fields
if field not in editable_fields and field not in exclude
]
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) + "\n"
def _check_has_add_permission(self, obj):
cls = obj.__class__
try:
func = cls.has_add_permission
except AttributeError:
pass
else:
args = get_func_args(func)
if 'obj' not in args:
warnings.warn(
"Update %s.has_add_permission() to accept a positional "
"`obj` argument." % cls.__name__, RemovedInDjango30Warning)
def _check_has_add_permission(self, obj):
cls = obj.__class__
try:
func = cls.has_add_permission
except AttributeError:
pass
else:
args = get_func_args(func)
if 'obj' not in args:
warnings.warn(
"Update %s.has_add_permission() to accept a positional "
"`obj` argument." % cls.__name__, RemovedInDjango30Warning
)
def handle(self, *args, **options):
data_source, model_name = options.pop('data_source'), options.pop(
'model_name')
if not gdal.HAS_GDAL:
raise CommandError(
'GDAL is required to inspect geospatial data sources.')
# 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) + '\n'
def __init__(self, func):
# Store the reference to the registered function
self.function = func
# @rpc_method decorator parameters
self._external_name = getattr(func, 'modernrpc_name', func.__name__)
self.entry_point = getattr(func, 'modernrpc_entry_point')
self.protocol = getattr(func, 'modernrpc_protocol')
self.str_standardization = getattr(func, 'str_standardization')
self.str_std_encoding = getattr(func, 'str_standardization_encoding')
# Authentication related attributes
self.predicates = getattr(func, 'modernrpc_auth_predicates', None)
self.predicates_params = getattr(func,
'modernrpc_auth_predicates_params',
())
# List method's positional arguments
# We can't use django.utils.inspect.get_func_args() with Python 2, because this function remove the first
# argument in returned list. This is supposed to remove the first 'self' argument, but doesn't fork well
# for global functions.
# For Python 2, we will prefer django.utils.inspect.getargspec(func)[0]. This will work as expected, even if
# the function has been removed in Django 2.0, since Django 2 doesn't work with Python 2
self.args = inspect.get_func_args(
func) if six.PY3 else inspect.getargspec(func)[0]
# Does the method accept additional kwargs dict?
self.accept_kwargs = inspect.func_accepts_kwargs(func)
# Contains the signature of the method, as returned by "system.methodSignature"
self.signature = []
# Contains the method's docstring, in HTML form
self.html_doc = ''
# Contains doc about arguments and their type. We store this in an ordered dict, so the args documentation
# keep the order defined in docstring
self.args_doc = collections.OrderedDict()
# Contains doc about return type and return value
self.return_doc = {}
# Docstring parsing
self.raw_docstring = self.parse_docstring(func.__doc__)
self.html_doc = self.raw_docstring_to_html(self.raw_docstring)
def handle(self, *args, **options):
data_source, model_name = options.pop('data_source'), options.pop('model_name')
if not gdal.HAS_GDAL:
raise CommandError('GDAL is required to inspect geospatial data sources.')
# 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) + '\n'
def serialize(self):
def _write(_arg_name, _arg_value):
if (_arg_name in self.operation.serialization_expand_args and
isinstance(_arg_value, (list, tuple, dict))):
if isinstance(_arg_value, dict):
self.feed('%s={' % _arg_name)
self.indent()
for key, value in _arg_value.items():
key_string, key_imports = MigrationWriter.serialize(key)
arg_string, arg_imports = MigrationWriter.serialize(value)
args = arg_string.splitlines()
if len(args) > 1:
self.feed('%s: %s' % (key_string, args[0]))
for arg in args[1:-1]:
self.feed(arg)
self.feed('%s,' % args[-1])
else:
self.feed('%s: %s,' % (key_string, arg_string))
imports.update(key_imports)
imports.update(arg_imports)
self.unindent()
self.feed('},')
else:
self.feed('%s=[' % _arg_name)
self.indent()
for item in _arg_value:
arg_string, arg_imports = MigrationWriter.serialize(item)
args = arg_string.splitlines()
if len(args) > 1:
for arg in args[:-1]:
self.feed(arg)
self.feed('%s,' % args[-1])
else:
self.feed('%s,' % arg_string)
imports.update(arg_imports)
self.unindent()
self.feed('],')
else:
arg_string, arg_imports = MigrationWriter.serialize(_arg_value)
args = arg_string.splitlines()
if len(args) > 1:
self.feed('%s=%s' % (_arg_name, args[0]))
for arg in args[1:-1]:
self.feed(arg)
self.feed('%s,' % args[-1])
else:
self.feed('%s=%s,' % (_arg_name, arg_string))
imports.update(arg_imports)
imports = set()
name, args, kwargs = self.operation.deconstruct()
operation_args = get_func_args(self.operation.__init__)
# See if this operation is in django.db.migrations. If it is,
# We can just use the fact we already have that imported,
# otherwise, we need to add an import for the operation class.
if getattr(migrations, name, None) == self.operation.__class__:
self.feed('migrations.%s(' % name)
else:
imports.add('import %s' % (self.operation.__class__.__module__))
self.feed('%s.%s(' % (self.operation.__class__.__module__, name))
self.indent()
for i, arg in enumerate(args):
arg_value = arg
arg_name = operation_args[i]
_write(arg_name, arg_value)
i = len(args)
# Only iterate over remaining arguments
for arg_name in operation_args[i:]:
if arg_name in kwargs: # Don't sort to maintain signature order
arg_value = kwargs[arg_name]
_write(arg_name, arg_value)
self.unindent()
self.feed('),')
return self.render(), imports
def serialize(self):
def _write(_arg_name, _arg_value):
if (_arg_name in self.operation.serialization_expand_args
and isinstance(_arg_value, (list, tuple, dict))):
if isinstance(_arg_value, dict):
self.feed('%s={' % _arg_name)
self.indent()
for key, value in _arg_value.items():
key_string, key_imports = MigrationWriter.serialize(
key)
arg_string, arg_imports = MigrationWriter.serialize(
value)
args = arg_string.splitlines()
if len(args) > 1:
self.feed('%s: %s' % (key_string, args[0]))
for arg in args[1:-1]:
self.feed(arg)
self.feed('%s,' % args[-1])
else:
self.feed('%s: %s,' % (key_string, arg_string))
imports.update(key_imports)
imports.update(arg_imports)
self.unindent()
self.feed('},')
else:
self.feed('%s=[' % _arg_name)
self.indent()
for item in _arg_value:
arg_string, arg_imports = MigrationWriter.serialize(
item)
args = arg_string.splitlines()
if len(args) > 1:
for arg in args[:-1]:
self.feed(arg)
self.feed('%s,' % args[-1])
else:
self.feed('%s,' % arg_string)
imports.update(arg_imports)
self.unindent()
self.feed('],')
else:
arg_string, arg_imports = MigrationWriter.serialize(_arg_value)
args = arg_string.splitlines()
if len(args) > 1:
self.feed('%s=%s' % (_arg_name, args[0]))
for arg in args[1:-1]:
self.feed(arg)
self.feed('%s,' % args[-1])
else:
self.feed('%s=%s,' % (_arg_name, arg_string))
imports.update(arg_imports)
imports = set()
name, args, kwargs = self.operation.deconstruct()
operation_args = get_func_args(self.operation.__init__)
# See if this operation is in django.db.migrations. If it is,
# We can just use the fact we already have that imported,
# otherwise, we need to add an import for the operation class.
if getattr(migrations, name, None) == self.operation.__class__:
self.feed('migrations.%s(' % name)
else:
imports.add('import %s' % (self.operation.__class__.__module__))
self.feed('%s.%s(' % (self.operation.__class__.__module__, name))
self.indent()
for i, arg in enumerate(args):
arg_value = arg
arg_name = operation_args[i]
_write(arg_name, arg_value)
i = len(args)
# Only iterate over remaining arguments
for arg_name in operation_args[i:]:
if arg_name in kwargs: # Don't sort to maintain signature order
arg_value = kwargs[arg_name]
_write(arg_name, arg_value)
self.unindent()
self.feed('),')
return self.render(), imports
def _basename_or_base_name(basename):
# freaking DRF... TODO: remove when dropping support for DRF 3.8
if 'basename' in get_func_args(routers.BaseRouter.register):
return {'basename': basename}
else:
return {'base_name': basename}
def serialize(self, app):
d = {}
def _write(_arg_name, _arg_value):
if (_arg_name in self.operation.serialization_expand_args and
isinstance(_arg_value, (list, tuple, dict))):
if isinstance(_arg_value, dict):
ds = {}
for a, b in _arg_value.items():
if any([isinstance(b, str), isinstance(b, list), isinstance(b, dict), isinstance(b, bool), isinstance(b, float), isinstance(b, int)]) or b is not None:
ds[a] = b
else:
ds[a] = str(b)
d[_arg_name] = ds
else:
f = []
for item in _arg_value:
if isinstance(item, tuple):
if len(item) == 2:
props = {}
i = item[1].__dict__
props["type_name"] = fullname(item[1])
props["choices"] = i.get("choices", None)
props["blank"] = i.get("blank", True)
props["is_null"] = i.get("null", True)
props["primary_key"] = i.get("primary_key", False)
props["help_text"] = i.get("help_text", '')
props["max_length"] = i.get("max_length", None)
props["verbose_name"] = i.get("verbose_name", None)
if "default" in i:
props["default"] = str(i["default"]) if type(i["default"]) not in [set, list, dict,
int, float, bool, type(None)] else \
i["default"]
else:
props["default"] = None
f.append({'name': str(item[0]), 'props': props})
else:
f.append(list(item))
elif any([isinstance(item, str), isinstance(item, list),
isinstance(item, dict), isinstance(item, bool),
isinstance(item, float),
isinstance(item, int)]) or item is None:
f.append(item)
else:
f.append(str(item))
d[_arg_name] = f
elif isinstance(_arg_value, ForeignKey):
ab = {
"many_to_many": bool(_arg_value.many_to_many),
"many_to_one": bool(_arg_value.many_to_one),
"one_to_many": bool(_arg_value.one_to_many),
"one_to_one": bool(_arg_value.one_to_one),
"field_str": str(_arg_value),
"to": str(_arg_value.remote_field.model).replace("__fake__.", "").replace("<class", "").replace("'", "").replace(">", "").replace(" ", ""),
}
d[_arg_name] = ab
d["related"] = True
elif isinstance(_arg_value, ManyToManyField):
ab = {
"many_to_many": bool(_arg_value.many_to_many),
"many_to_one": bool(_arg_value.many_to_one),
"one_to_many": bool(_arg_value.one_to_many),
"one_to_one": bool(_arg_value.one_to_one),
"field_str": str(_arg_value),
"to": str(_arg_value.remote_field.model).replace("__fake__.", "").replace("<class", "").replace("'", "").replace(">", "").replace(" ", ""),
}
d[_arg_name] = ab
d["related"] = True
elif any([isinstance(_arg_value, str), isinstance(_arg_value, list), isinstance(_arg_value, dict), isinstance(_arg_value, bool), isinstance(_arg_value, float), isinstance(_arg_value, int)]) or _arg_value is None:
d[_arg_name] = _arg_value
else:
d[_arg_name] = str(_arg_value)
name, args, kwargs = self.operation.deconstruct()
operation_args = get_func_args(self.operation.__init__)
for i, arg in enumerate(args):
arg_value = arg
arg_name = operation_args[i]
_write(arg_name, arg_value)
i = len(args)
for arg_name in operation_args[i:]:
if arg_name in kwargs:
arg_value = kwargs[arg_name]
_write(arg_name, arg_value)
if "name" in d:
d["name"] = app + "." + d["name"]
return d
from __future__ import unicode_literals
import argparse