def handle(self, object_class, *ids, **options):
(app_label, model_name) = object_class.split('.')
dump_me = loading.get_model(app_label, model_name)
try:
objs = dump_me.objects.filter(pk__in=[int(i) for i in ids])
except ValueError:
# We might have primary keys thar are just strings...
objs = dump_me.objects.filter(pk__in=ids)
if options.get('kitchensink'):
related_fields = [rel.get_accessor_name() for rel in
dump_me._meta.get_all_related_objects()]
for obj in objs:
for rel in related_fields:
try:
add_to_serialize_list(obj.__getattribute__(rel).all())
except FieldError:
pass
except ObjectDoesNotExist:
pass
add_to_serialize_list(objs)
serialize_fully()
print serialize('json', [o for o in serialize_me if o is not None],
indent=4)
def handle(self, dump_name, *pks, **options):
# Get the primary object
dump_settings = settings.CUSTOM_DUMPS[dump_name]
(app_label, model_name) = dump_settings['primary'].split('.')
dump_me = loading.get_model(app_label, model_name)
objs = dump_me.objects.filter(pk__in=[int(i) for i in pks])
for obj in objs:
# get the dependent objects and add to serialize list
for dep in dump_settings['dependents']:
try:
thing = Variable("thing.%s" % dep).resolve({'thing': obj})
add_to_serialize_list([thing])
except VariableDoesNotExist:
sys.stderr.write('%s not found' % dep)
if not dump_settings['dependents']:
add_to_serialize_list([obj])
serialize_fully()
data = serialize('json', [o for o in serialize_me if o is not None])
data = reorder_json(json.loads(data), dump_settings.get('order', []),
ordering_cond=dump_settings.get('order_cond',{}))
print json.dumps(data, indent=4)
def handle(self, dump_name, *pks, **options):
# Get the primary object
dump_settings = settings.CUSTOM_DUMPS[dump_name]
(app_label, model_name) = dump_settings['primary'].split('.')
dump_me = loading.get_model(app_label, model_name)
objs = dump_me.objects.filter(pk__in=[int(i) for i in pks])
for obj in objs:
# get the dependent objects and add to serialize list
for dep in dump_settings['dependents']:
try:
thing = Variable("thing.%s" % dep).resolve({'thing': obj})
add_to_serialize_list([thing])
except VariableDoesNotExist:
sys.stderr.write('%s not found' % dep)
if not dump_settings['dependents']:
add_to_serialize_list([obj])
serialize_fully()
data = serialize('json', [o for o in serialize_me if o is not None])
data = reorder_json(json.loads(data),
dump_settings.get('order', []),
ordering_cond=dump_settings.get('order_cond', {}))
print json.dumps(data, indent=4)
def handle(self, *args, **options):
error_text = ('%s\nTry calling dump_object with --help argument or ' +
'use the following arguments:\n %s' % self.args)
try:
#verify input is valid
(app_label, model_name) = args[0].split('.')
ids = args[1:]
assert (ids)
except IndexError:
raise CommandError(error_text %
'No object_class or filter clause supplied.')
except ValueError:
raise CommandError(error_text %
("object_class must be provided in" +
" the following format: app_name.model_name"))
except AssertionError:
raise CommandError(error_text % 'No filter argument supplied.')
dump_me = loading.get_model(app_label, model_name)
if ids[0] == '*':
objs = dump_me.objects.all()
else:
try:
objs = dump_me.objects.filter(pk__in=[int(i) for i in ids])
except ValueError:
# We might have primary keys that are longs...
try:
objs = dump_me.objects.filter(
pk__in=[long(i) for i in ids])
except ValueError:
# or json objects for better filter control
try:
objs = dump_me.objects.filter(**json.loads(ids[0]))
except ValueError:
# Finally, we might have primary keys that are strings...
objs = dump_me.objects.filter(pk__in=ids)
if options.get('kitchensink'):
related_fields = [
rel.get_accessor_name()
for rel in dump_me._meta.get_all_related_objects()
]
for obj in objs:
for rel in related_fields:
try:
add_to_serialize_list(obj.__getattribute__(rel).all())
except FieldError:
pass
except ObjectDoesNotExist:
pass
add_to_serialize_list(objs)
serialize_fully()
self.stdout.write(
serialize('json', [o for o in serialize_me if o is not None],
indent=4))
def serialize_fully():
index = 0
while index < len(serialize_me):
for field in get_fields(serialize_me[index]):
if isinstance(field, models.ForeignKey):
add_to_serialize_list(
[serialize_me[index].__getattribute__(field.name)])
index += 1
serialize_me.reverse()
def serialize_fully():
index = 0
while index < len(serialize_me):
for field in get_fields(serialize_me[index]):
if isinstance(field, models.ForeignKey):
add_to_serialize_list(
[serialize_me[index].__getattribute__(field.name)])
index += 1
serialize_me.reverse()
def handle(self, *args, **options):
error_text = ('%s\nTry calling dump_object with --help argument or ' +
'use the following arguments:\n %s' %self.args)
try:
#verify input is valid
(app_label, model_name) = args[0].split('.')
ids = args[1:]
assert(ids)
except IndexError:
raise CommandError(error_text %'No object_class or filter clause supplied.')
except ValueError:
raise CommandError(error_text %("object_class must be provided in"+
" the following format: app_name.model_name"))
except AssertionError:
raise CommandError(error_text %'No filter argument supplied.')
dump_me = loading.get_model(app_label, model_name)
if ids[0] == '*':
objs = dump_me.objects.all()
else:
try:
objs = dump_me.objects.filter(pk__in=[int(i) for i in ids])
except ValueError:
# We might have primary keys that are longs...
try :
objs = dump_me.objects.filter(pk__in=[long(i) for i in ids])
except ValueError:
# or json objects for better filter control
try:
objs = dump_me.objects.filter(**json.loads(ids[0]))
except ValueError:
# Finally, we might have primary keys that are strings...
objs = dump_me.objects.filter(pk__in=ids)
if options.get('kitchensink'):
related_fields = [rel.get_accessor_name() for rel in
dump_me._meta.get_all_related_objects()]
for obj in objs:
for rel in related_fields:
try:
add_to_serialize_list(obj.__getattribute__(rel).all())
except FieldError:
pass
except ObjectDoesNotExist:
pass
add_to_serialize_list(objs)
serialize_fully()
self.stdout.write(serialize('json', [o for o in serialize_me if o is not None],
indent=4))
def add_to_serialize_list(objs):
for obj in objs:
if obj is None:
continue
if not hasattr(obj, '_meta'):
add_to_serialize_list(obj)
continue
# Proxy models don't serialize well in Django.
if obj._meta.proxy:
obj = obj._meta.proxy_for_model.objects.get(pk=obj.pk)
key = "%s:%s:%s" % (obj._meta.app_label, obj._meta.module_name, obj.pk)
if key not in seen:
serialize_me.append(obj)
seen[key] = 1
def add_to_serialize_list(objs):
for obj in objs:
if obj is None:
continue
if not hasattr(obj, '_meta'):
add_to_serialize_list(obj)
continue
# Proxy models don't serialize well in Django.
if obj._meta.proxy:
obj = obj._meta.proxy_for_model.objects.get(pk=obj.pk)
key = "%s:%s:%s" % (obj._meta.app_label, obj._meta.module_name,
obj.pk)
if key not in seen:
serialize_me.append(obj)
seen[key] = 1
def handle(self, dump_name, pk, **options):
# Get the primary object
dump_settings = settings.CUSTOM_DUMPS[dump_name]
(app_label, model_name) = dump_settings['primary'].split('.')
dump_me = loading.get_model(app_label, model_name)
obj = dump_me.objects.get(pk=pk)
# get the dependent objects and add to serialize list
for dep in dump_settings['dependents']:
thing = Variable("thing.%s" % dep).resolve({'thing': obj})
add_to_serialize_list([thing])
serialize_fully()
data = serialize('json', [o for o in serialize_me if o is not None])
data = reorder_json(json.loads(data), dump_settings.get('order', []))
print json.dumps(data, indent=4)
def process_dep(parent, dep, serialize_me, seen):
parts = dep.split('.')
current = parts.pop(0)
leftover = '.'.join(parts)
try:
thing = getattr(parent, current)
except AttributeError:
pass # related object not found
else:
if hasattr(thing, 'all'):
children = thing.all()
else:
children = [thing]
add_to_serialize_list(children, serialize_me, seen)
if leftover:
for child in children:
process_dep(child, leftover, serialize_me, seen)
def handle(self, dump_name, *ids, **options):
# Get the primary object
dump_settings = settings.CUSTOM_DUMPS[dump_name]
(app_label, model_name) = dump_settings['primary'].split('.')
dump_me = loading.get_model(app_label, model_name)
if ids[0] == '*':
objs = dump_me.objects.all()
else:
try:
objs = dump_me.objects.filter(pk__in=[int(i) for i in ids])
except ValueError:
# We might have primary keys that are longs...
try:
objs = dump_me.objects.filter(
pk__in=[long(i) for i in ids])
except ValueError:
# or json objects for better filter control
try:
objs = dump_me.objects.filter(**json.loads(ids[0]))
except ValueError:
# Finally, we might have primary keys that are strings...
objs = dump_me.objects.filter(pk__in=ids)
for obj in objs:
# get the dependent objects and add to serialize list
for dep in dump_settings['dependents']:
try:
thing = Variable("thing.%s" % dep).resolve({'thing': obj})
add_to_serialize_list([thing])
except VariableDoesNotExist:
sys.stderr.write('%s not found' % dep)
if not dump_settings['dependents']:
add_to_serialize_list([obj])
serialize_fully()
data = serialize('json', [o for o in serialize_me if o is not None])
data = reorder_json(json.loads(data),
dump_settings.get('order', []),
ordering_cond=dump_settings.get('order_cond', {}))
print json.dumps(data, indent=4)
def handle(self, dump_name, *ids, **options):
# Get the primary object
dump_settings = settings.CUSTOM_DUMPS[dump_name]
(app_label, model_name) = dump_settings["primary"].split(".")
dump_me = loading.get_model(app_label, model_name)
if ids[0] == "*":
objs = dump_me.objects.all()
else:
try:
objs = dump_me.objects.filter(pk__in=[int(i) for i in ids])
except ValueError:
# We might have primary keys that are longs...
try:
objs = dump_me.objects.filter(pk__in=[long(i) for i in ids])
except ValueError:
# or json objects for better filter control
try:
objs = dump_me.objects.filter(**json.loads(ids[0]))
except ValueError:
# Finally, we might have primary keys that are strings...
objs = dump_me.objects.filter(pk__in=ids)
for obj in objs:
# get the dependent objects and add to serialize list
for dep in dump_settings["dependents"]:
try:
thing = Variable("thing.%s" % dep).resolve({"thing": obj})
add_to_serialize_list([thing])
except VariableDoesNotExist:
sys.stderr.write("%s not found" % dep)
if not dump_settings["dependents"]:
add_to_serialize_list([obj])
serialize_fully()
data = serialize("json", [o for o in serialize_me if o is not None])
data = reorder_json(
json.loads(data), dump_settings.get("order", []), ordering_cond=dump_settings.get("order_cond", {})
)
print json.dumps(data, indent=4)
def export_ary_fixture():
for model in apps.get_app_config('ary').get_models():
label = model._meta.label
if label in IGNORE_MODELS:
continue
objs = model.objects.all()
add_to_serialize_list(objs)
serialize_fully()
data = serialize('json',
sorted(
[o for o in serialize_me if o is not None],
key=lambda x:
(f'{x._meta.app_label}.{x._meta.model_name}', x.pk),
),
indent=2,
use_natural_foreign_keys=False,
use_natural_primary_keys=False)
del serialize_me[:]
seen.clear()
return data
def handle(self, *args, **options):
# Get the primary object
dump_name = options["dump_name"]
pks = options["pk"]
dump_settings = settings.CUSTOM_DUMPS[dump_name]
(app_label, model_name) = dump_settings["primary"].split(".")
include_primary = dump_settings.get("include_primary", False)
dump_me = loading.get_model(app_label, model_name)
objs = dump_me.objects.filter(pk__in=[int(i) for i in pks])
for obj in objs.all():
# get the dependent objects and add to serialize list
for dep in dump_settings["dependents"]:
try:
thing = Variable("thing.%s" % dep).resolve({"thing": obj})
if hasattr(
thing,
"all"): # Related managers can't be iterated over
thing = thing.all()
add_to_serialize_list([thing])
except VariableDoesNotExist:
sys.stderr.write("%s not found" % dep)
if include_primary or not dump_settings["dependents"]:
add_to_serialize_list([obj])
serialize_fully()
data = serialize(
"json",
[o for o in serialize_me if o is not None],
indent=4,
use_natural_foreign_keys=options.get("natural", False),
use_natural_primary_keys=options.get("natural", False),
)
data = reorder_json(
json.loads(data),
dump_settings.get("order", []),
ordering_cond=dump_settings.get("order_cond", {}),
)
print(json.dumps(data, indent=4))
def handle(self, *args, **options):
serialize_me = []
seen = set()
# Get the primary object
dump_name = options['dump_name']
pks = options['pk']
dump_settings = settings.CUSTOM_DUMPS[dump_name]
app_label, model_name, *manager_method = dump_settings[
'primary'].split('.')
include_primary = dump_settings.get("include_primary", False)
default_manager = loading.get_model(app_label, model_name).objects
if manager_method:
queryset = getattr(default_manager, manager_method[0])()
else:
queryset = default_manager.all()
if pks:
queryset = queryset.filter(pk__in=pks)
deps = dump_settings.get('dependents', [])
for obj in queryset:
# get the dependent objects and add to serialize list
for dep in deps:
process_dep(obj, dep, serialize_me, seen)
if include_primary or not deps:
add_to_serialize_list([obj], serialize_me, seen)
serialize_fully(serialize_me, seen)
data = serialize(
'json',
[o for o in serialize_me if o is not None],
indent=4,
use_natural_foreign_keys=options.get('natural', False),
use_natural_primary_keys=options.get('natural', False),
)
data = reorder_json(json.loads(data),
dump_settings.get('order', []),
ordering_cond=dump_settings.get('order_cond', {}))
self.stdout.write(json.dumps(data, indent=4))
def handle(self, *args, **options):
error_text = (
"%s\nTry caling dump_object with --help argument or use" + " the following arguments:\n %s" % self.args
)
try:
# verify input is valid
(app_label, model_name) = args[0].split(".")
ids = args[1:]
assert ids
except IndexError:
raise CommandError(error_text % "No object_class or id arguments supplied.")
except ValueError:
raise CommandError(
error_text % ("object_class must be provided in" + " the following format: app_name.model_name")
)
except AssertionError:
raise CommandError(error_text % "No id arguments supplied.")
dump_me = loading.get_model(app_label, model_name)
try:
objs = dump_me.objects.filter(pk__in=[int(i) for i in ids])
except ValueError:
# We might have primary keys thar are just strings...
objs = dump_me.objects.filter(pk__in=ids)
if options.get("kitchensink"):
related_fields = [rel.get_accessor_name() for rel in dump_me._meta.get_all_related_objects()]
for obj in objs:
for rel in related_fields:
try:
add_to_serialize_list(obj.__getattribute__(rel).all())
except FieldError:
pass
except ObjectDoesNotExist:
pass
add_to_serialize_list(objs)
serialize_fully()
print serialize("json", [o for o in serialize_me if o is not None], indent=4)
def handle(self, *args, **options):
error_text = ('%s\nTry calling dump_object with --help argument or ' +
'use the following arguments:\n %s' %self.args)
try:
#verify input is valid
(app_label, model_name) = args[0].split('.')
query = options['query']
ids = args[1:]
if ids and query:
raise CommandError(error_text % 'either use query or id list, not both')
if not (ids or query):
raise CommandError(error_text % 'must pass list of ids or a json --query')
except IndexError:
raise CommandError(error_text %'No object_class or filter clause supplied.')
except ValueError:
raise CommandError(error_text %("object_class must be provided in"
" the following format: app_name.model_name"))
except AssertionError:
raise CommandError(error_text %'No filter argument supplied.')
dump_me = loading.get_model(app_label, model_name)
if query:
objs = dump_me.objects.filter(**json.loads(query))
else:
if ids[0] == '*':
objs = dump_me.objects.all()
else:
for parser in int, long, str:
try:
objs = dump_me.objects.filter(pk__in=map(parser, ids))
except ValueError:
pass
else:
break
if options.get('kitchensink'):
related_fields = [rel.get_accessor_name() for rel in
dump_me._meta.get_all_related_objects()]
for obj in objs:
for rel in related_fields:
try:
if hasattr(getattr(obj, rel), 'all'):
add_to_serialize_list(getattr(obj, rel).all())
else:
add_to_serialize_list([getattr(obj, rel)])
except FieldError:
pass
except ObjectDoesNotExist:
pass
add_to_serialize_list(objs)
serialize_fully()
self.stdout.write(serialize('json', [o for o in serialize_me if o is not None],
indent=4,
use_natural_foreign_keys=options.get('natural', False),
use_natural_primary_keys=options.get('natural', False)))
# Clear the list. Useful for when calling multiple dump_object commands with a single execution of django
del serialize_me[:]
def handle(self, *args, **options):
# Get the primary object
dump_name = options['dump_name']
pks = options['pk']
dump_settings = settings.CUSTOM_DUMPS[dump_name]
(app_label, model_name) = dump_settings['primary'].split('.')
include_primary = dump_settings.get("include_primary", False)
dump_me = loading.get_model(app_label, model_name)
objs = dump_me.objects.filter(pk__in=[int(i) for i in pks])
for obj in objs.all():
# get the dependent objects and add to serialize list
for dep in dump_settings['dependents']:
try:
thing = Variable("thing.%s" % dep).resolve({'thing': obj})
if hasattr(thing, 'all'): # Related managers can't be iterated over
thing = thing.all()
add_to_serialize_list([thing])
except VariableDoesNotExist:
sys.stderr.write('%s not found' % dep)
if include_primary or not dump_settings['dependents']:
add_to_serialize_list([obj])
serialize_fully()
data = serialize('json', [o for o in serialize_me if o is not None],
indent=4,
use_natural_foreign_keys=options.get('natural', False),
use_natural_primary_keys=options.get('natural', False),
)
data = reorder_json(
json.loads(data),
dump_settings.get('order', []),
ordering_cond=dump_settings.get('order_cond', {})
)
print(json.dumps(data, indent=4))
def handle(self, *args, **options):
error_text = ('%s\nTry calling dump_object with --help argument or ' +
'use the following arguments:\n %s' % self.args)
try:
# verify input is valid
try:
(app_label, model_name) = options['model'].split('.')
except AttributeError:
raise CommandError("Specify model as `appname.modelname")
query = options['query']
ids = options['ids']
if ids and query:
raise CommandError(error_text %
'either use query or id list, not both')
if not (ids or query):
raise CommandError(error_text %
'must pass list of --ids or a json --query')
except IndexError:
raise CommandError(error_text %
'No object_class or filter clause supplied.')
except ValueError:
raise CommandError(
error_text %
"object_class must be provided in the following format: app_name.model_name"
)
except AssertionError:
raise CommandError(error_text % 'No filter argument supplied.')
dump_me = loading.get_model(app_label, model_name)
if query:
objs = dump_me.objects.filter(**json.loads(query))
else:
if ids[0] == '*':
objs = dump_me.objects.all()
elif 'limit:' in ids[0]:
try:
limit = int(ids[0].replace('limit:', ''))
objs = dump_me.objects.all()[:limit]
except:
raise CommandError(
'Recheck the command it should be limit:N, N is the limit.'
)
else:
try:
parsers = int, long, str
except NameError:
parsers = int, str
for parser in parsers:
try:
objs = dump_me.objects.filter(pk__in=map(parser, ids))
except ValueError:
pass
else:
break
if options.get('kitchensink'):
fields = get_all_related_objects(dump_me)
related_fields = [rel.get_accessor_name() for rel in fields]
for obj in objs:
for rel in related_fields:
try:
if hasattr(getattr(obj, rel), 'all'):
add_to_serialize_list(getattr(obj, rel).all())
else:
add_to_serialize_list([getattr(obj, rel)])
except FieldError:
pass
except ObjectDoesNotExist:
pass
add_to_serialize_list(objs)
if options.get('follow_fk', True):
serialize_fully()
else:
# reverse list to match output of serializez_fully
serialize_me.reverse()
natural_foreign = (options.get('natural', False)
or options.get('natural_foreign', False))
natural_primary = (options.get('natural', False)
or options.get('natural_primary', False))
self.stdout.write(
serialize(options.get('format', 'json'),
[o for o in serialize_me if o is not None],
indent=4,
use_natural_foreign_keys=natural_foreign,
use_natural_primary_keys=natural_primary))
# Clear the list. Useful for when calling multiple
# dump_object commands with a single execution of django
del serialize_me[:]
seen.clear()
def handle(self, *args, **options):
error_text = ('%s\nTry calling dump_object with --help argument or ' +
'use the following arguments:\n %s' % self.args)
try:
#verify input is valid
try:
(app_label, model_name) = options['model'].split('.')
except AttributeError:
raise CommandError("Specify model as `appname.modelname")
query = options['query']
ids = options['ids']
config_name = options['config_name']
if ids and query:
raise CommandError(error_text %
'either use query or id list, not both')
if not (ids or query):
raise CommandError(error_text %
'must pass list of --ids or a json --query')
except IndexError:
raise CommandError(error_text %
'No object_class or filter clause supplied.')
except ValueError:
raise CommandError(error_text %
("object_class must be provided in"
" the following format: app_name.model_name"))
except AssertionError:
raise CommandError(error_text % 'No filter argument supplied.')
dump_me = loading.get_model(app_label, model_name)
if query:
objs = dump_me.objects.filter(**json.loads(query))
else:
if ids[0] == '*':
objs = dump_me.objects.all()
else:
try:
parsers = int, long, str
except NameError:
parsers = int, str
for parser in parsers:
try:
objs = dump_me.objects.filter(pk__in=map(parser, ids))
except ValueError:
pass
else:
break
if options.get('kitchensink'):
if django.VERSION >= (1, 8):
fields = (
f for f in dump_me._meta.get_fields()
if (f.one_to_many or f.one_to_one) and f.auto_created)
else:
fields = dump_me._meta.get_all_related_objects()
related_fields = [rel.get_accessor_name() for rel in fields]
for obj in objs:
for rel in related_fields:
try:
if hasattr(getattr(obj, rel), 'all'):
add_to_serialize_list(getattr(obj, rel).all())
else:
add_to_serialize_list([getattr(obj, rel)])
except FieldError:
pass
except ObjectDoesNotExist:
pass
try:
dump_settings = settings.CUSTOM_DUMPS[config_name]
except Exception:
dump_settings = None
add_to_serialize_list(objs)
serialize_fully()
data = serialize(
options.get('format',
'json'), [o for o in serialize_me if o is not None],
indent=4,
use_natural_foreign_keys=options.get('natural', False),
use_natural_primary_keys=options.get('natural', False))
if dump_settings and dump_settings.get('order', []):
data = reorder_json(json.loads(data),
dump_settings.get('order', []),
ordering_cond=dump_settings.get(
'order_cond', {}))
self.stdout.write(json.dumps(data))
# Clear the list. Useful for when calling multiple dump_object commands with a single execution of django
del serialize_me[:]
seen.clear()
def handle(self, *args, **options):
error_text = (
"%s\nTry calling dump_object with --help argument or " + "use the following arguments:\n %s" % self.args
)
try:
# verify input is valid
(app_label, model_name) = args[0].split(".")
query = options["query"]
ids = args[1:]
if ids and query:
raise CommandError(error_text % "either use query or id list, not both")
if not (ids or query):
raise CommandError(error_text % "must pass list of ids or a json --query")
except IndexError:
raise CommandError(error_text % "No object_class or filter clause supplied.")
except ValueError:
raise CommandError(
error_text % ("object_class must be provided in" " the following format: app_name.model_name")
)
except AssertionError:
raise CommandError(error_text % "No filter argument supplied.")
dump_me = loading.get_model(app_label, model_name)
if query:
objs = dump_me.objects.filter(**json.loads(query))
else:
if ids[0] == "*":
objs = dump_me.objects.all()
else:
for parser in int, long, str:
try:
objs = dump_me.objects.filter(pk__in=map(parser, ids))
except ValueError:
pass
else:
break
if options.get("kitchensink"):
related_fields = [rel.get_accessor_name() for rel in dump_me._meta.get_all_related_objects()]
for obj in objs:
for rel in related_fields:
try:
if hasattr(getattr(obj, rel), "all"):
add_to_serialize_list(getattr(obj, rel).all())
else:
add_to_serialize_list([getattr(obj, rel)])
except FieldError:
pass
except ObjectDoesNotExist:
pass
add_to_serialize_list(objs)
serialize_fully()
self.stdout.write(
serialize(
"json",
[o for o in serialize_me if o is not None],
indent=4,
use_natural_keys=options.get("natural", False),
)
)
def handle(self, *args, **options):
error_text = ('%s\nTry calling dump_object with --help argument or use'+
' the following arguments:\n %s' %self.args)
try:
#verify input is valid
main_model = args[0]
(app_label, model_name) = main_model.split('.')
ids = args[1:]
# assert(ids)
except IndexError:
raise CommandError(error_text %'No object_class or id arguments supplied.')
except ValueError:
raise CommandError(error_text %("object_class must be provided in"+
" the following format: app_name.model_name"))
except AssertionError:
raise CommandError(error_text %'No id arguments supplied.')
exclude_list = [
_.strip()
for _ in options['exclude_list'].replace(' ',',').split(',')
if _.strip()
]
filter_list = [
_.strip()
for _ in options['filter_list'].replace(' ',',').split(',')
if _.strip()
]
# Lookup initial model.
dump_me = loading.get_model(app_label, model_name)
# Lookup initial model records.
if ids:
try:
objs = dump_me.objects.filter(pk__in=[int(i) for i in ids])
except ValueError:
# We might have primary keys that are just strings...
objs = dump_me.objects.filter(pk__in=ids)
elif options.get('limit'):
limit = int(options.get('limit'))
objs = dump_me.objects.order_by('?')[:limit]
else:
objs = dump_me.objects.all()
main_model = main_model.lower()
depends_on = defaultdict(set) # {key:set(keys being pointed to)}
key_to_object = {}
serialization_order = []
max_depth = options.get('kitchensink_depth')
max_depth = int(max_depth) if max_depth is not None else None
if options.get('kitchensink') or options.get('just_fk_kitchensink'):
# Recursively serialize all related objects.
priors = set()
queue = list(objs)
queue = zip(queue, [0]*len(queue)) #queue is obj, depth
while queue:
obj, depth = queue.pop(0)
# Abort cyclic references.
if obj in priors:
continue
priors.add(obj)
obj_key = get_key(obj)
key_to_object[obj_key] = obj
# Skip ignored models.
rel_name = obj._meta.app_label+'.'+obj._meta.module_name
rel_name = rel_name.lower()
if rel_name in exclude_list:
continue
# Skip models not specifically being filtered by.
if rel_name != main_model and filter_list and rel_name not in filter_list:
continue
#abort max depth in kitchensink
abort_max_depth = False
if max_depth is not None and depth > max_depth:
abort_max_depth = True
# Serialize relations.
if options.get('just_fk_kitchensink') or abort_max_depth:
related_fields = []
else:
related_fields = [
rel.get_accessor_name()
for rel in obj._meta.get_all_related_objects()
] + [
m2m_rel.name
for m2m_rel in obj._meta.many_to_many
]
kitchensink_limit = options.get('kitchensink_limit')
kitchensink_limit = int(kitchensink_limit) if kitchensink_limit is not None else None
for rel in related_fields:
try:
related_objs = obj.__getattribute__(rel)
#handle OneToOneField case for related object
if isinstance(related_objs, models.Model):
related_objs = [related_objs]
else: #everything else uses a related manager
related_objs = related_objs.all()
if kitchensink_limit:
related_objs = related_objs[:kitchensink_limit]
for rel_obj in related_objs:
if rel_obj in priors:
continue
rel_key = get_key(rel_obj)
key_to_object[rel_key] = rel_obj
depends_on[rel_key].add(obj_key)
queue.append((rel_obj, depth+1))
except FieldError:
pass
except ObjectDoesNotExist:
pass
# Serialize foreign keys.
for field in obj._meta.fields:
if isinstance(field, ForeignKey):
fk_obj = obj.__getattribute__(field.name)
if fk_obj:
fk_key = get_key(fk_obj)
key_to_object[fk_key] = fk_obj
depends_on[obj_key].add(fk_key)
queue.append((fk_obj, depth+1))
# Serialize current object.
serialization_order.append(obj)
else:
# Only serialize the immediate objects.
serialization_order = objs
# Order serialization so that dependents come after dependencies.
def cmp_depends(a, b):
if a in depends_on[b]:
return -1
elif b in depends_on[a]:
return +1
return cmp(get_key(a, as_tuple=True), get_key(b, as_tuple=True))
serialization_order = list(serialization_order)
serialization_order.sort(cmp=cmp_depends)
add_to_serialize_list(serialization_order)
output = serialize('json', [o for o in serialize_me if o is not None],
indent=4, use_natural_keys=options['natural'])
# Remove primary keys so records will not conflict with future existing
# models, relying on natural keys to resolve ambiguity.
if options['natural']:
matches = re.findall('"pk":\s*[0-9]+,', output)
for match in matches:
output = output.replace(match, '"pk": null,')
return output
def dump_object(model,
query,
ids,
order=[],
ignore=[],
related_ignore={},
additional_serialization_objects_fnc=None,
format='json',
kitchensink=True,
follow_fk=True,
natural=False,
natural_foreign=False,
natural_primary=False):
serialize_me = []
seen = set()
error_text = ('Error\n')
try:
# verify input is valid
try:
(app_label, model_name) = model.split('.')
except AttributeError:
raise CommandError("Specify model as `appname.modelname")
if ids and query:
raise CommandError(error_text % 'either use query or id list, not both')
if not (ids or query):
raise CommandError(error_text % 'must pass list of --ids or a json --query')
except IndexError:
raise CommandError(error_text % 'No object_class or filter clause supplied.')
except ValueError as e:
raise CommandError(
error_text %
"object_class must be provided in the following format: app_name.model_name"
)
except AssertionError:
raise CommandError(error_text % 'No filter argument supplied.')
dump_me = loading.get_model(app_label, model_name)
if query:
objs = dump_me.objects.filter(**json.loads(query))
else:
if ids[0] == '*':
objs = dump_me.objects.all()
else:
try:
parsers = int, long, str
except NameError:
parsers = int, str
for parser in parsers:
try:
objs = dump_me.objects.filter(pk__in=map(parser, ids))
except ValueError:
pass
else:
break
if kitchensink:
fields = get_all_related_objects(dump_me)
# if there are no related ignores for this model include the field
# or if this related field is not in the related ignores include the field
related_fields = [rel.get_accessor_name() for rel in fields if
model_name not in related_ignore or
rel.name not in related_ignore[model_name]]
generic_foreign_key_fields = get_all_generic_foreign_keys(dump_me)
for field in generic_foreign_key_fields:
if model_name not in related_ignore or field.name not in related_ignore[model_name]:
related_fields.append(field.name)
for obj in objs:
for rel in related_fields:
try:
if hasattr(getattr(obj, rel), 'all'):
add_to_serialize_list(getattr(obj, rel).all(), serialize_me, seen, ignore=ignore)
else:
add_to_serialize_list([getattr(obj, rel)], serialize_me, seen, ignore=ignore)
# allow user to add additional data apart from standard foreign keys
if additional_serialization_objects_fnc and \
callable(additional_serialization_objects_fnc):
extra_objs = additional_serialization_objects_fnc(getattr(obj, rel))
if extra_objs:
add_to_serialize_list(extra_objs, serialize_me, seen, ignore=ignore)
except FieldError:
pass
except ObjectDoesNotExist:
pass
add_to_serialize_list(objs, serialize_me, seen, prepend=True, ignore=ignore)
if follow_fk:
serialize_fully(serialize_me, seen, ignore, additional_serialization_objects_fnc)
else:
# reverse list to match output of serializez_fully
serialize_me.reverse()
natural_foreign = (natural or
natural_foreign)
natural_primary = (natural or
natural_primary)
if format:
if format == "json":
data = CustomJsonSerializer().serialize(
[o for o in serialize_me if o is not None],
indent=4,
use_natural_foreign_keys=natural_foreign,
use_natural_primary_keys=natural_primary)
else:
data = serialize(format,
[o for o in serialize_me if o is not None],
indent=4,
use_natural_foreign_keys=natural_foreign,
use_natural_primary_keys=natural_primary)
data = reorder_json(
json.loads(data),
order,
)
return json.dumps(data, indent=4)
# return unserialized objs
return [o for o in serialize_me if o is not None]
def handle(self, *args, **options):
error_text = (
"%s\nTry calling dump_object with --help argument or " + "use the following arguments:\n %s" % self.args
)
try:
# verify input is valid
try:
(app_label, model_name) = options["model"].split(".")
except AttributeError:
raise CommandError("Specify model as `appname.modelname")
query = options["query"]
ids = options["ids"]
if ids and query:
raise CommandError(error_text % "either use query or id list, not both")
if not (ids or query):
raise CommandError(error_text % "must pass list of --ids or a json --query")
except IndexError:
raise CommandError(error_text % "No object_class or filter clause supplied.")
except ValueError:
raise CommandError(
error_text % ("object_class must be provided in" " the following format: app_name.model_name")
)
except AssertionError:
raise CommandError(error_text % "No filter argument supplied.")
dump_me = loading.get_model(app_label, model_name)
if query:
objs = dump_me.objects.filter(**json.loads(query))
else:
if ids[0] == "*":
objs = dump_me.objects.all()
else:
try:
parsers = int, long, str
except NameError:
parsers = int, str
for parser in parsers:
try:
objs = dump_me.objects.filter(pk__in=map(parser, ids))
except ValueError:
pass
else:
break
if options.get("kitchensink"):
if django.VERSION >= (1, 8):
fields = (f for f in dump_me._meta.get_fields() if (f.one_to_many or f.one_to_one) and f.auto_created)
else:
fields = dump_me._meta.get_all_related_objects()
related_fields = [rel.get_accessor_name() for rel in fields]
for obj in objs:
for rel in related_fields:
try:
if hasattr(getattr(obj, rel), "all"):
add_to_serialize_list(getattr(obj, rel).all())
else:
add_to_serialize_list([getattr(obj, rel)])
except FieldError:
pass
except ObjectDoesNotExist:
pass
add_to_serialize_list(objs)
serialize_fully()
self.stdout.write(
serialize(
options.get("format", "json"),
[o for o in serialize_me if o is not None],
indent=4,
use_natural_foreign_keys=options.get("natural", False),
use_natural_primary_keys=options.get("natural", False),
)
)
# Clear the list. Useful for when calling multiple dump_object commands with a single execution of django
del serialize_me[:]
seen.clear()
def handle(self, *args, **options):
serialize_me = []
seen = set()
error_text = ('%s\nTry calling dump_object with --help argument or ' +
'use the following arguments:\n %s' % self.args)
try:
# verify input is valid
try:
(app_label, model_name) = options['model'].split('.')
except AttributeError:
raise CommandError("Specify model as `appname.modelname")
query = options['query']
ids = options['ids']
if options['order']:
options['order'] = json.loads(options['order'])
ignore = []
if options['ignore']:
ignore = json.loads(options['ignore'])
related_ignore = []
if options['related_ignore']:
related_ignore = json.loads(options['related_ignore'])
if ids and query:
raise CommandError(error_text % 'either use query or id list, not both')
if not (ids or query):
raise CommandError(error_text % 'must pass list of --ids or a json --query')
except IndexError:
raise CommandError(error_text % 'No object_class or filter clause supplied.')
except ValueError as e:
raise CommandError(
error_text %
"object_class must be provided in the following format: app_name.model_name"
)
except AssertionError:
raise CommandError(error_text % 'No filter argument supplied.')
dump_me = loading.get_model(app_label, model_name)
if query:
objs = dump_me.objects.filter(**json.loads(query))
else:
if ids[0] == '*':
objs = dump_me.objects.all()
else:
try:
parsers = int, long, str
except NameError:
parsers = int, str
for parser in parsers:
try:
objs = dump_me.objects.filter(pk__in=map(parser, ids))
except ValueError:
pass
else:
break
else:
objs = []
if options.get('kitchensink'):
fields = get_all_related_objects(dump_me)
# if there are no related ignores for this model include the field
# or if this related field is not in the related ignores include the field
related_fields = [rel.get_accessor_name() for rel in fields if
model_name not in related_ignore or
rel.name not in related_ignore[model_name]]
for obj in objs:
for rel in related_fields:
try:
if hasattr(getattr(obj, rel), 'all'):
add_to_serialize_list(getattr(obj, rel).all(),
serialize_me, seen, ignore=ignore)
else:
add_to_serialize_list([getattr(obj, rel)],
serialize_me, seen, ignore=ignore)
except FieldError:
pass
except ObjectDoesNotExist:
pass
add_to_serialize_list(objs, serialize_me, seen, prepend=True, ignore=ignore)
if options.get('follow_fk', True):
serialize_fully(serialize_me, seen, ignore)
else:
# reverse list to match output of serializez_fully
serialize_me.reverse()
natural_foreign = (options.get('natural', False) or
options.get('natural_foreign', False))
natural_primary = (options.get('natural', False) or
options.get('natural_primary', False))
data = serialize(options.get('format', 'json'),
[o for o in serialize_me if o is not None],
indent=4,
use_natural_foreign_keys=natural_foreign,
use_natural_primary_keys=natural_primary)
data = reorder_json(
json.loads(data),
options.get('order', []),
)
self.stdout.write(json.dumps(data, indent=4))
def handle(self, *args, **options):
error_text = ('%s\nTry calling dump_object with --help argument or ' +
'use the following arguments:\n %s' % self.args)
try:
#verify input is valid
(app_label, model_name) = args[0].split('.')
query = options['query']
ids = args[1:]
if ids and query:
raise CommandError(error_text %
'either use query or id list, not both')
if not (ids or query):
raise CommandError(error_text %
'must pass list of ids or a json --query')
except IndexError:
raise CommandError(error_text %
'No object_class or filter clause supplied.')
except ValueError:
raise CommandError(error_text %
("object_class must be provided in"
" the following format: app_name.model_name"))
except AssertionError:
raise CommandError(error_text % 'No filter argument supplied.')
dump_me = loading.get_model(app_label, model_name)
if query:
objs = dump_me.objects.filter(**json.loads(query))
else:
if ids[0] == '*':
objs = dump_me.objects.all()
else:
for parser in int, long, str:
try:
objs = dump_me.objects.filter(pk__in=map(parser, ids))
except ValueError:
pass
else:
break
if options.get('kitchensink'):
related_fields = [
rel.get_accessor_name()
for rel in dump_me._meta.get_all_related_objects()
]
for obj in objs:
for rel in related_fields:
try:
if hasattr(getattr(obj, rel), 'all'):
add_to_serialize_list(getattr(obj, rel).all())
else:
add_to_serialize_list([getattr(obj, rel)])
except FieldError:
pass
except ObjectDoesNotExist:
pass
add_to_serialize_list(objs)
serialize_fully()
self.stdout.write(
serialize('json', [o for o in serialize_me if o is not None],
indent=4,
use_natural_foreign_keys=options.get('natural', False),
use_natural_primary_keys=options.get('natural', False)))
# Clear the list. Useful for when calling multiple dump_object commands with a single execution of django
del serialize_me[:]
def handle(self, *args, **options):
error_text = (
"%s\nTry calling dump_object with --help argument or "
+ "use the following arguments:\n %s" % self.args
)
try:
# verify input is valid
try:
(app_label, model_name) = options["model"].split(".")
except AttributeError:
raise CommandError("Specify model as `appname.modelname")
query = options["query"]
ids = options["ids"]
if ids and query:
raise CommandError(error_text % "either use query or id list, not both")
if not (ids or query):
raise CommandError(
error_text % "must pass list of --ids or a json --query"
)
except IndexError:
raise CommandError(
error_text % "No object_class or filter clause supplied."
)
except ValueError:
raise CommandError(
error_text
% "object_class must be provided in the following format: app_name.model_name"
)
except AssertionError:
raise CommandError(error_text % "No filter argument supplied.")
dump_me = loading.get_model(app_label, model_name)
if query:
objs = dump_me.objects.filter(**json.loads(query))
else:
if ids[0] == "*":
objs = dump_me.objects.all()
else:
try:
parsers = int, long, str
except NameError:
parsers = int, str
for parser in parsers:
try:
objs = dump_me.objects.filter(pk__in=map(parser, ids))
except ValueError:
pass
else:
break
if options.get("kitchensink"):
fields = get_all_related_objects(dump_me)
related_fields = [rel.get_accessor_name() for rel in fields]
for obj in objs:
for rel in related_fields:
try:
if hasattr(getattr(obj, rel), "all"):
add_to_serialize_list(getattr(obj, rel).all())
else:
add_to_serialize_list([getattr(obj, rel)])
except FieldError:
pass
except ObjectDoesNotExist:
pass
if options["count"] is not None:
objs = objs.all()[: options["count"]]
add_to_serialize_list(objs)
if options.get("follow_fk", True):
serialize_fully()
else:
# reverse list to match output of serializez_fully
serialize_me.reverse()
natural_foreign = options.get("natural", False) or options.get(
"natural_foreign", False
)
natural_primary = options.get("natural", False) or options.get(
"natural_primary", False
)
self.stdout.write(
serialize(
options.get("format", "json"),
[o for o in serialize_me if o is not None],
indent=4,
use_natural_foreign_keys=natural_foreign,
use_natural_primary_keys=natural_primary,
)
)
# Clear the list. Useful for when calling multiple
# dump_object commands with a single execution of django
del serialize_me[:]
seen.clear()
