def __init_subclass_with_meta__(cls,
serializer_class=None,
only_fields=(),
exclude_fields=(),
**options):
if not serializer_class:
raise Exception(
'serializer_class is required for the SerializerMutation')
serializer = serializer_class()
input_fields = fields_for_serializer(serializer,
only_fields,
exclude_fields,
is_input=True)
output_fields = fields_for_serializer(serializer,
only_fields,
exclude_fields,
is_input=False)
_meta = SerializerMutationOptions(cls)
_meta.serializer_class = serializer_class
_meta.fields = yank_fields_from_attrs(
output_fields,
_as=Field,
)
input_fields = yank_fields_from_attrs(
input_fields,
_as=InputField,
)
super(SerializerMutation,
cls).__init_subclass_with_meta__(_meta=_meta,
input_fields=input_fields,
**options)
def __init_subclass_with_meta__(cls,
lookup_field=None,
serializer_class=None,
model_class=None,
model_operations=("create", "update"),
only_fields=(),
exclude_fields=(),
convert_choices_to_enum=True,
_meta=None,
**options):
if not serializer_class:
raise Exception(
"serializer_class is required for the SerializerMutation")
if "update" not in model_operations and "create" not in model_operations:
raise Exception(
'model_operations must contain "create" and/or "update"')
serializer = serializer_class()
if model_class is None:
serializer_meta = getattr(serializer_class, "Meta", None)
if serializer_meta:
model_class = getattr(serializer_meta, "model", None)
if lookup_field is None and model_class:
lookup_field = model_class._meta.pk.name
input_fields = fields_for_serializer(
serializer,
only_fields,
exclude_fields,
is_input=True,
convert_choices_to_enum=convert_choices_to_enum,
lookup_field=lookup_field,
)
output_fields = fields_for_serializer(
serializer,
only_fields,
exclude_fields,
is_input=False,
convert_choices_to_enum=convert_choices_to_enum,
lookup_field=lookup_field,
)
if not _meta:
_meta = SerializerMutationOptions(cls)
_meta.lookup_field = lookup_field
_meta.model_operations = model_operations
_meta.serializer_class = serializer_class
_meta.model_class = model_class
_meta.fields = yank_fields_from_attrs(output_fields, _as=Field)
input_fields = yank_fields_from_attrs(input_fields, _as=InputField)
super(SerializerMutation,
cls).__init_subclass_with_meta__(_meta=_meta,
input_fields=input_fields,
**options)
def __init_subclass_with_meta__(cls,
lookup_field=None,
serializer_class=None,
model_class=None,
node_class=None,
only_fields=(),
exclude_fields=(),
is_update=False,
**options):
if not serializer_class:
raise Exception(
"serializer_class is required for SerializerMutation")
serializer = serializer_class()
if model_class is None:
serializer_meta = getattr(serializer_class, "Meta", None)
if serializer_meta:
model_class = getattr(serializer_meta, "model", None)
if node_class and not issubclass(node_class, graphene.relay.Node):
raise Exception("node_class must be a subclass of relay.Node")
if lookup_field is None and model_class:
lookup_field = model_class._meta.pk.name
input_fields = fields_for_serializer(serializer,
only_fields,
exclude_fields,
is_input=True,
is_update=is_update)
output_fields = fields_for_serializer(serializer,
only_fields,
exclude_fields,
is_input=False,
is_update=is_update)
if is_update:
input_fields["id"] = graphene.ID(
required=True, description="ID of the object to update.")
_meta = SerializerMutationOptions(cls)
_meta.lookup_field = lookup_field
_meta.serializer_class = serializer_class
_meta.model_class = model_class
_meta.fields = yank_fields_from_attrs(output_fields, _as=Field)
if node_class:
_meta.node_class = node_class
input_fields = yank_fields_from_attrs(input_fields, _as=InputField)
super(SerializerBaseMutation,
cls).__init_subclass_with_meta__(_meta=_meta,
input_fields=input_fields,
**options)
def __init_subclass_with_meta__(cls, lookup_field=None,
serializer_class=None, model_class=None,
model_operations=['create', 'update'],
only_fields=(), exclude_fields=(), **options):
if not serializer_class:
raise Exception('serializer_class is required for the SerializerMutation')
if 'update' not in model_operations and 'create' not in model_operations:
raise Exception('model_operations must contain "create" and/or "update"')
serializer = serializer_class()
if model_class is None:
serializer_meta = getattr(serializer_class, 'Meta', None)
if serializer_meta:
model_class = getattr(serializer_meta, 'model', None)
if lookup_field is None and model_class:
lookup_field = model_class._meta.pk.name
input_fields = fields_for_serializer(serializer, only_fields, exclude_fields, is_input=True)
output_fields = fields_for_serializer(serializer, only_fields, exclude_fields, is_input=False)
_meta = SerializerMutationOptions(cls)
_meta.lookup_field = lookup_field
_meta.model_operations = model_operations
_meta.serializer_class = serializer_class
_meta.model_class = model_class
_meta.fields = yank_fields_from_attrs(
output_fields,
_as=Field,
)
input_fields = yank_fields_from_attrs(
input_fields,
_as=InputField,
)
super(SerializerMutation, cls).__init_subclass_with_meta__(_meta=_meta, input_fields=input_fields, **options)
def __new__(cls, name, bases, attrs):
if not is_base_type(bases, SerializerMutationMeta):
return type.__new__(cls, name, bases, attrs)
options = Options(
attrs.pop('Meta', None),
name=name,
description=attrs.pop('__doc__', None),
serializer_class=None,
local_fields=None,
only_fields=(),
exclude_fields=(),
interfaces=(),
registry=None
)
if not options.serializer_class:
raise Exception('Missing serializer_class')
cls = ObjectTypeMeta.__new__(
cls, name, bases, dict(attrs, _meta=options)
)
serializer_fields = cls.fields_for_serializer(options)
options.serializer_fields = yank_fields_from_attrs(
serializer_fields,
_as=Field,
)
options.fields = merge(
options.interface_fields, options.serializer_fields,
options.base_fields, options.local_fields,
{'errors': get_field_as(cls.errors, Field)}
)
cls.Input = convert_serializer_to_input_type(options.serializer_class)
cls.Field = partial(
Field,
cls,
resolver=cls.mutate,
input=Argument(cls.Input, required=True)
)
return cls
def __new__(cls, name, bases, attrs):
if not is_base_type(bases, SerializerMutationMeta):
return type.__new__(cls, name, bases, attrs)
options = Options(attrs.pop('Meta', None),
name=name,
description=attrs.pop('__doc__', None),
serializer_class=None,
local_fields=None,
only_fields=(),
exclude_fields=(),
interfaces=(),
registry=None)
if not options.serializer_class:
raise Exception('Missing serializer_class')
cls = ObjectTypeMeta.__new__(cls, name, bases,
dict(attrs, _meta=options))
serializer_fields = cls.fields_for_serializer(options)
options.serializer_fields = yank_fields_from_attrs(
serializer_fields,
_as=Field,
)
options.fields = merge(options.interface_fields,
options.serializer_fields, options.base_fields,
options.local_fields,
{'errors': get_field_as(cls.errors, Field)})
cls.Input = convert_serializer_to_input_type(options.serializer_class)
cls.Field = partial(Field,
cls,
resolver=cls.mutate,
input=Argument(cls.Input, required=True))
return cls
def __new__(mcs, name, bases, attrs):
if not is_base_type(bases, NdbObjectTypeMeta):
return type.__new__(mcs, name, bases, attrs)
options = Options(attrs.pop('Meta', None),
name=name,
description=attrs.pop('__doc__', None),
model=None,
local_fields=None,
only_fields=(),
exclude_fields=(),
interfaces=(),
registry=None)
if not options.model:
raise Exception(
'NdbObjectType %s must have a model in the Meta class attr' %
name)
if not inspect.isclass(options.model) or not issubclass(
options.model, ndb.Model):
raise Exception('Provided model in %s is not an NDB model' % name)
new_cls = ObjectTypeMeta.__new__(mcs, name, bases,
dict(attrs, _meta=options))
mcs.register(new_cls)
ndb_fields = mcs.fields_for_ndb_model(options)
options.ndb_fields = yank_fields_from_attrs(
ndb_fields,
_as=Field,
)
options.fields = merge(options.interface_fields, options.ndb_fields,
options.base_fields, options.local_fields)
return new_cls
def __init_subclass_with_meta__(
cls,
lookup_field=None,
serializer_class=None,
model_class=None,
node_class=None,
only_fields=(),
exclude_fields=(),
is_update=False,
id_input_field=None,
partial=False,
convert_choices_to_enum=True,
registry=None,
**options
):
if not serializer_class:
raise Exception(
"serializer_class is required for SerializerClientIDMutation"
)
serializer = serializer_class()
if model_class is None:
serializer_meta = getattr(serializer_class, "Meta", None)
if serializer_meta:
model_class = getattr(serializer_meta, "model", None)
if node_class and not issubclass(node_class, graphene.relay.Node):
raise Exception("node_class must be a subclass of relay.Node")
if is_update and not model_class:
raise Exception("model_class is required for SerializerClientIDMutation")
if lookup_field is None and model_class:
lookup_field = model_class._meta.pk.name
input_fields = fields_for_serializer(
serializer,
only_fields,
exclude_fields,
registry,
is_input=True,
is_update=is_update,
is_partial=partial,
convert_choices_to_enum=convert_choices_to_enum,
)
output_fields = fields_for_serializer(
serializer,
only_fields,
exclude_fields,
registry,
is_input=False,
is_update=is_update,
is_partial=partial,
convert_choices_to_enum=convert_choices_to_enum,
)
if is_update and id_input_field:
input_fields = OrderedDict(
**{
id_input_field: graphene.ID(
required=True, description="ID of the object to update."
)
},
**input_fields
)
_meta = SerializerMutationOptions(cls)
_meta.is_update = is_update
_meta.lookup_field = lookup_field
_meta.id_input_field = id_input_field
_meta.partial = partial
_meta.serializer_class = serializer_class
_meta.model_class = model_class
_meta.registry = registry
_meta.fields = yank_fields_from_attrs(output_fields, _as=Field)
if node_class:
_meta.node_class = node_class
input_fields = yank_fields_from_attrs(input_fields, _as=InputField)
super(SerializerBaseClientIDMutation, cls).__init_subclass_with_meta__(
_meta=_meta, input_fields=input_fields, **options
)
def __init_subclass_with_meta__(cls,
lookup_field=None,
lookup_input_kwarg=None,
serializer_class=None,
model_class=None,
model_operations=["create", "update"],
fields=(),
exclude=(),
return_field_name=None,
return_field_type=None,
**options):
if not serializer_class:
raise Exception("serializer_class is required for the Mutation")
if "update" not in model_operations and "create" not in model_operations:
raise Exception(
'model_operations must contain "create" and/or "update"')
serializer = serializer_class()
if model_class is None:
serializer_meta = getattr(serializer_class, "Meta", None)
if serializer_meta:
model_class = getattr(serializer_meta, "model", None)
if lookup_field is None and model_class:
lookup_field = model_class._meta.pk.name
if lookup_input_kwarg is None:
lookup_input_kwarg = lookup_field
input_fields = fields_for_serializer(serializer,
fields,
exclude,
is_input=True)
if return_field_name is None:
model_name = model_class.__name__
return_field_name = model_name[:1].lower() + model_name[1:]
if not return_field_type:
registry = get_global_registry()
return_field_type = registry.get_type_for_model(model_class)
output_fields = OrderedDict()
if return_field_name:
output_fields[return_field_name] = graphene.Field(
return_field_type)
_meta = MutationOptions(cls)
_meta.lookup_field = lookup_field
_meta.lookup_input_kwarg = lookup_input_kwarg
_meta.model_operations = model_operations
_meta.serializer_class = serializer_class
_meta.model_class = model_class
_meta.fields = yank_fields_from_attrs(output_fields, _as=Field)
_meta.return_field_name = return_field_name
_meta.return_field_type = return_field_type
input_fields = yank_fields_from_attrs(input_fields, _as=InputField)
super().__init_subclass_with_meta__(_meta=_meta,
input_fields=input_fields,
**options)
