def nested_update(instance, key, value, objects=None):
objects = objects or []
nested = getattr(instance, key, None)
def fix(x):
s = str(x).lower()
if s == "true":
return "True"
if s == "false":
return "False"
return x
value = {k: fix(v) for k, v in value.items()}
if not nested:
# object does not exist, try to create it
try:
field = get_model_field(instance, key)
related_model = get_related_model(field)
except:
raise exceptions.ValidationError('Invalid relationship: %s' % key)
else:
nested = related_model.objects.create(**value)
setattr(instance, key, nested)
else:
# object exists, perform a nested update
for k, v in six.iteritems(value):
if isinstance(v, dict):
nested_update(nested, k, v, objects)
else:
setattr(nested, k, v)
objects.append(nested)
return objects
def _build_implicit_prefetches(
self,
model,
prefetches,
requirements
):
"""Build a prefetch dictionary based on internal requirements."""
for source, remainder in six.iteritems(requirements):
if not remainder or isinstance(remainder, six.string_types):
# no further requirements to prefetch
continue
related_field = get_model_field(model, source)
related_model = get_related_model(related_field)
queryset = self._build_implicit_queryset(
related_model,
remainder
) if related_model else None
prefetches[source] = self._create_prefetch(
source,
queryset
)
return prefetches
def serializer_class(self):
"""Get the class of the child serializer.
Resolves string imports.
"""
serializer_class = self._serializer_class
if serializer_class is None:
from dynamic_rest.routers import DynamicRouter
serializer_class = DynamicRouter.get_canonical_serializer(
None, model=get_related_model(self.model_field))
if not isinstance(serializer_class, six.string_types):
return serializer_class
parts = serializer_class.split('.')
module_path = '.'.join(parts[:-1])
if not module_path:
if getattr(self, 'parent', None) is None:
raise Exception(
"Can not load serializer '%s'" % serializer_class +
' before binding or without specifying full path')
# try the module of the parent class
module_path = self.parent.__module__
module = importlib.import_module(module_path)
serializer_class = getattr(module, parts[-1])
self._serializer_class = serializer_class
return serializer_class