def __new__(cls, name, bases, attrs):
# Also ensure initialization is only performed for subclasses of
# SQLAlchemyInterface (excluding SQLAlchemyInterface class itself).
if not is_base_type(bases, SQLAlchemyInterfaceMeta):
return type.__new__(cls, 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=(),
# id='id',
registry=None
)
if not options.registry:
options.registry = get_global_registry()
assert isinstance(options.registry, Registry), (
'The attribute registry in {}.Meta needs to be an'
' instance of Registry, received "{}".'
).format(name, options.registry)
assert is_mapped(options.model), (
'You need to pass a valid SQLAlchemy Model in '
'{}.Meta, received "{}".'
).format(name, options.model)
cls = type.__new__(cls, name, bases, dict(attrs, _meta=options))
options.base_fields = ()
options.base_fields = get_base_fields(bases, _as=Field)
if not options.local_fields:
options.local_fields = yank_fields_from_attrs(attrs, _as=Field)
# options.registry.register(cls)
options.fields = merge(
options.base_fields,
options.local_fields
)
options.sqlalchemy_fields = yank_fields_from_attrs(
construct_fields(options),
_as=Field,
)
options.fields = merge(
options.sqlalchemy_fields,
options.base_fields,
options.local_fields
)
return cls
def __init_subclass_with_meta__(cls, model=None, container=None, registry=None, skip_registry=False,
connection=None, use_connection=None, only_fields=(), exclude_fields=(),
filter_fields=None, input_for="create", nested_fields=False, **options):
assert is_valid_django_model(model), (
'You need to pass a valid Django Model in {}.Meta, received "{}".'
).format(cls.__name__, model)
if not registry:
registry = get_global_registry()
assert isinstance(registry, Registry), (
'The attribute registry in {} needs to be an instance of '
'Registry, received "{}".'
).format(cls.__name__, registry)
assert input_for.lower not in ('create', 'delete', 'update'), (
'You need to pass a valid input_for value in {}.Meta, received "{}".'
).format(cls.__name__, input_for)
input_for = input_for.lower()
if not DJANGO_FILTER_INSTALLED and filter_fields:
raise Exception("Can only set filter_fields if Django-Filter is installed")
django_fields = yank_fields_from_attrs(
construct_fields(model, registry, only_fields, exclude_fields, None, nested_fields),
_as=Field, sort=False
)
django_input_fields = yank_fields_from_attrs(
construct_fields(model, registry, only_fields, exclude_fields, input_for, nested_fields),
_as=InputField, sort=False
)
if container is None:
container = type(cls.__name__, (InputObjectTypeContainer, cls), {})
_meta = DjangoObjectOptions(cls)
_meta.by_polar = True
_meta.model = model
_meta.registry = registry
_meta.filter_fields = filter_fields
# _meta.fields = django_fields
_meta.fields = django_input_fields
_meta.input_fields = django_input_fields
_meta.container = container
_meta.connection = connection
_meta.input_for = input_for
super(DjangoInputObjectType, cls).__init_subclass_with_meta__(_meta=_meta, **options)
if not skip_registry:
registry.register(cls, for_input=input_for)
def __new__(cls, name, bases, attrs):
# Also ensure initialization is only performed for subclasses of
# DjangoObjectType
if not is_base_type(bases, DjangoObjectTypeMeta):
return type.__new__(cls, name, bases, attrs)
defaults = dict(
name=name,
description=attrs.pop('__doc__', None),
model=None,
local_fields=None,
only_fields=(),
exclude_fields=(),
interfaces=(),
registry=None
)
if DJANGO_FILTER_INSTALLED:
# In case Django filter is available, then
# we allow more attributes in Meta
defaults.update(
filter_fields=(),
filter_order_by=(),
)
options = Options(
attrs.pop('Meta', None),
**defaults
)
if not options.registry:
options.registry = get_global_registry()
assert isinstance(options.registry, Registry), (
'The attribute registry in {}.Meta needs to be an instance of '
'Registry, received "{}".'
).format(name, options.registry)
assert is_valid_django_model(options.model), (
'You need to pass a valid Django Model in {}.Meta, received "{}".'
).format(name, options.model)
cls = ObjectTypeMeta.__new__(cls, name, bases, dict(attrs, _meta=options))
options.registry.register(cls)
options.django_fields = yank_fields_from_attrs(
construct_fields(options),
_as=Field,
)
options.fields = merge(
options.interface_fields,
options.django_fields,
options.base_fields,
options.local_fields
)
return cls
def __init_subclass_with_meta__(cls, model=None, registry=None, skip_registry=False,
only_fields=(), exclude_fields=(), connection=None,
use_connection=None, interfaces=(), **options):
if not model:
raise Exception((
'NdbObjectType {name} must have a model in the Meta class attr'
).format(name=cls.__name__))
if not inspect.isclass(model) or not issubclass(model, ndb.Model):
raise Exception((
'Provided model in {name} is not an NDB model'
).format(name=cls.__name__))
if not registry:
registry = get_global_registry()
assert isinstance(registry, Registry), (
'The attribute registry in {} needs to be an instance of '
'Registry, received "{}".'
).format(cls.__name__, registry)
ndb_fields = fields_for_ndb_model(model, registry, only_fields, exclude_fields)
ndb_fields = yank_fields_from_attrs(
ndb_fields,
_as=Field,
)
if use_connection is None and interfaces:
use_connection = any((issubclass(interface, Node) for interface in interfaces))
if use_connection and not connection:
# We create the connection automatically
connection = Connection.create_type('{}Connection'.format(cls.__name__), node=cls)
if connection is not None:
assert issubclass(connection, Connection), (
"The connection must be a Connection. Received {}"
).format(connection.__name__)
_meta = NdbObjectTypeOptions(cls)
_meta.model = model
_meta.registry = registry
_meta.fields = ndb_fields
_meta.connection = connection
super(NdbObjectType, cls).__init_subclass_with_meta__(_meta=_meta, interfaces=interfaces, **options)
if not skip_registry:
registry.register(cls)
def __new__(cls, name, bases, attrs):
# Also ensure initialization is only performed for subclasses of Model
# (excluding Model class itself).
if not is_base_type(bases, SQLAlchemyObjectTypeMeta):
return type.__new__(cls, name, bases, attrs)
meta = attrs.pop('Meta', None)
local_fields = OrderedDict({k:v for k,v in attrs.items() if _is_graphql(v)})
options = Options(
meta,
name=name,
description=attrs.pop('__doc__', getattr(meta.model, '__doc__', None)),
model=None,
local_fields=local_fields,
exclude_fields=set(),
interfaces=(),
registry=None
)
if not options.registry:
options.registry = get_global_registry()
assert isinstance(options.registry, Registry), (
'The attribute registry in {}.Meta needs to be an'
' instance of Registry, received "{}".'
).format(name, options.registry)
assert is_mapped(options.model), (
'You need to pass a valid SQLAlchemy Model in '
'{}.Meta, received "{}".'
).format(name, options.model)
cls = ObjectTypeMeta.__new__(cls, name, bases, dict(attrs, _meta=options))
options.registry.register(cls)
options.sqlalchemy_fields = yank_fields_from_attrs(
construct_fields(options),
_as = graphene.Field,
)
options.fields = merge(
options.interface_fields,
options.sqlalchemy_fields,
options.base_fields,
options.local_fields
)
return cls
def __init_subclass_with_meta__(
cls,
model=None,
registry=None,
skip_registry=False,
only_fields=(),
exclude_fields=(),
filter_fields=None,
interfaces=(),
filterset_class=None,
**options
):
assert is_valid_django_model(model), (
'You need to pass a valid Django Model in {}.Meta, received "{}".'
).format(cls.__name__, model)
if not registry:
registry = get_global_registry()
assert isinstance(registry, Registry), (
'The attribute registry in {} needs to be an instance of '
'Registry, received "{}".'
).format(cls.__name__, registry)
if not DJANGO_FILTER_INSTALLED and (filter_fields or filterset_class):
raise Exception(
"Can only set filter_fields or filterset_class if Django-Filter is installed"
)
django_fields = yank_fields_from_attrs(
construct_fields(model, registry, only_fields, exclude_fields),
_as=Field,
)
_meta = DjangoObjectOptions(cls)
_meta.model = model
_meta.registry = registry
_meta.filter_fields = filter_fields
_meta.fields = django_fields
_meta.filterset_class = filterset_class
super(DjangoObjectType, cls).__init_subclass_with_meta__(_meta=_meta, interfaces=interfaces, **options)
if not skip_registry:
registry.register(cls)
def __init_subclass_with_meta__(
cls, _meta=None, model=None, filterset_class=None, fields=None, **options
):
cls.custom_filterset_class = filterset_class
cls.filterset_class = None
cls.fields = fields
cls.model = model
if not _meta:
_meta = InputObjectTypeOptions(cls)
fields = cls.get_filtering_args_from_filterset()
fields = yank_fields_from_attrs(fields, _as=InputField)
if _meta.fields:
_meta.fields.update(fields)
else:
_meta.fields = fields
super().__init_subclass_with_meta__(_meta=_meta, **options)
def __init_subclass_with_meta__(cls,
resolver=None,
output=None,
arguments=None,
_meta=None,
**options):
if not _meta:
_meta = FieldResolverOptions(cls)
output = output or getattr(cls, 'Output', None)
fields = {}
if not output:
# If output is defined, we don't need to get the fields
fields = OrderedDict()
for base in reversed(cls.__mro__):
fields.update(yank_fields_from_attrs(base.__dict__, _as=Field))
output = cls
if not arguments:
input_class = getattr(cls, 'Arguments', None)
if input_class:
arguments = props(input_class)
else:
arguments = {}
if not resolver:
_resolver = getattr(cls, 'resolve', None)
assert _resolver, 'All field resolvers must define a resolve method'
resolver = get_unbound_function(_resolver)
if _meta.fields:
_meta.fields.update(fields)
else:
_meta.fields = fields
_meta.output = output
_meta.resolver = resolver
_meta.arguments = arguments
super(FieldResolver, cls).__init_subclass_with_meta__(_meta=_meta,
**options)
def __init_subclass_with_meta__(cls, model=None, registry=None,
only_fields=(), exclude_fields=(),
interfaces=(), **options):
odoo_fields = yank_fields_from_attrs(
construct_fields(model, registry, only_fields, exclude_fields),
_as=Field,
)
_meta = OdooObjectTypeOptions(cls)
_meta.model = model
_meta.registry = registry
_meta.fields = odoo_fields
super(OdooObjectType, cls).__init_subclass_with_meta__(
_meta=_meta,
interfaces=interfaces,
**options
)
registry[model._name]._schema = cls
def __init_subclass_with_meta__(cls, **options):
fields = OrderedDict()
for base in reversed(cls.__mro__):
fields.update(yank_fields_from_attrs(base.__dict__, _as=Field))
base = options['base']
for name in fields.keys():
assert name not in base._meta.fields, "{name} already exists in {base}".format(
name=name, base=base.__name__)
assert not hasattr(base, "resolve_{}".format(
name)), "{base} already has {name} resolver".format(
name=name, base=base.__name__)
resolver = getattr(cls, "resolve_{}".format(name), None)
if resolver:
setattr(base, "resolve_{}".format(name), resolver)
base._meta.fields.update(fields)
super(Extension, cls).__init_subclass_with_meta__()
def __init_subclass_with_meta__(
cls,
model=None,
permissions=None,
login_required=None,
filter_fields=(),
filter_class=None,
**kwargs,
):
registry = get_global_registry()
model_type = registry.get_type_for_model(model)
assert model_type, f"Model type must be registered for model {model}"
assert (
len(filter_fields) > 0
), f"You must specify at least one field to filter on for deletion."
input_arguments = get_filter_fields_input_args(filter_fields, model)
InputType = type(f"BatchDelete{model.__name__}Input",
(InputObjectType, ), input_arguments)
arguments = OrderedDict(input=InputType(required=True))
output_fields = OrderedDict()
output_fields["deletion_count"] = graphene.Int()
output_fields["deleted_ids"] = graphene.List(graphene.ID)
_meta = DjangoBatchDeleteMutationOptions(cls)
_meta.model = model
_meta.fields = yank_fields_from_attrs(output_fields,
_as=graphene.Field)
_meta.filter_fields = filter_fields
_meta.permissions = permissions
_meta.login_required = _meta.login_required or (
_meta.permissions and len(_meta.permissions) > 0)
super().__init_subclass_with_meta__(arguments=arguments,
_meta=_meta,
**kwargs)
def __init_subclass_with_meta__(
cls,
_meta=None,
model=None,
permissions=None,
login_required=None,
only_fields=(),
exclude_fields=(),
return_field_name=None,
**kwargs,
):
registry = get_global_registry()
model_type = registry.get_type_for_model(model)
assert model_type, f"Model type must be registered for model {model}"
if not return_field_name:
return_field_name = to_snake_case(model.__name__)
arguments = OrderedDict(id=graphene.ID(required=True))
output_fields = OrderedDict()
output_fields["found"] = graphene.Boolean()
output_fields["deleted_input_id"] = graphene.ID()
output_fields["deleted_id"] = graphene.ID()
output_fields["deleted_raw_id"] = graphene.ID()
if _meta is None:
_meta = DjangoDeleteMutationOptions(cls)
_meta.model = model
_meta.model_type = model_type
_meta.fields = yank_fields_from_attrs(output_fields, _as=graphene.Field)
_meta.return_field_name = return_field_name
_meta.permissions = permissions
_meta.login_required = login_required or (
_meta.permissions and len(_meta.permissions) > 0
)
super().__init_subclass_with_meta__(arguments=arguments, _meta=_meta, **kwargs)
def __init_subclass_with_meta__(cls,
model=None,
registry=None,
only_fields=[],
exclude_fields=[],
**options):
if not registry:
registry = get_global_registry()
autoexclude = []
foreign_keys = []
# always pull ids out to a separate argument
for col in sqlalchemy.inspect(model).columns:
if col.foreign_keys:
foreign_keys.append(col.name)
continue
if (col.primary_key and col.autoincrement) or (
isinstance(col.type, sqlalchemy.types.TIMESTAMP)
and col.server_default is not None):
autoexclude.append(col.name)
sqla_fields = yank_fields_from_attrs(
construct_fields(
obj_type=SQLAlchemyObjectTypes().get(model),
model=model,
registry=registry,
only_fields=tuple(only_fields),
exclude_fields=tuple(exclude_fields + autoexclude),
connection_field_factory=default_connection_field_factory,
),
_as=graphene.Field,
)
# Add all of the fields to the input type
for key, value in sqla_fields.items():
if not (isinstance(value, Dynamic) or hasattr(cls, key)):
if key in foreign_keys:
value = graphene.ID(description="Global Id")
setattr(cls, key, value)
super(SQLAlchemyInputObjectType,
cls).__init_subclass_with_meta__(**options)
def __init_subclass_with_meta__(cls,
_meta=None,
model=None,
filterset_class=None,
fields=None,
**options):
cls.custom_filterset_class = filterset_class
cls.filterset_class = None
cls.fields = fields
cls.model = model
if not _meta:
_meta = InputObjectTypeOptions(cls)
fields = cls.get_filtering_args_from_filterset()
fields = yank_fields_from_attrs(fields, _as=InputField)
if _meta.fields:
_meta.fields.update(fields)
else:
_meta.fields = fields
super().__init_subclass_with_meta__(_meta=_meta, **options)
def __init_subclass_with_meta__(cls, model=None,
object_permissions=None,
object_permissions_any=True,
return_field_name=None,
required_fields=None,
exclude_fields=None, only_fields=None,
_meta=None, **kwargs):
if not model: # pragma: no cover
raise ImproperlyConfigured("model is required for ModelMutation")
if not _meta:
_meta = ModelMutationOptions(cls)
exclude_fields = exclude_fields or []
only_fields = only_fields or []
if not return_field_name:
return_field_name = _get_model_name(model)
input_fields = _get_fields(model, only_fields, exclude_fields,
required_fields)
input_fields = yank_fields_from_attrs(input_fields, _as=graphene.InputField)
fields = _get_output_fields(model, return_field_name)
_meta.model = model
_meta.object_permissions = object_permissions or []
_meta.object_permissions_any = object_permissions_any
_meta.return_field_name = return_field_name
_meta.exclude_fields = exclude_fields
_meta.only_fields = only_fields
_meta.required_fields = required_fields
super().__init_subclass_with_meta__(
_meta=_meta,
input_fields=input_fields,
**kwargs,
)
cls._meta.fields.update(fields)
def __init_subclass_with_meta__(
cls,
_meta=None,
model=None,
permissions=None,
login_required=None,
only_fields=(),
exclude_fields=(),
return_field_name=None,
**kwargs,
):
registry = get_global_registry()
if not return_field_name:
return_field_name = to_snake_case(model.__name__)
arguments = OrderedDict(ids=graphene.List(graphene.ID, required=True))
output_fields = OrderedDict()
output_fields["deletion_count"] = graphene.Int()
output_fields["deleted_ids"] = graphene.List(graphene.ID)
output_fields["missed_ids"] = graphene.List(graphene.ID)
if _meta is None:
_meta = DjangoBatchDeleteMutationOptions(cls)
_meta.model = model
_meta.fields = yank_fields_from_attrs(output_fields,
_as=graphene.Field)
_meta.return_field_name = return_field_name
_meta.permissions = permissions
_meta.login_required = login_required or (_meta.permissions and
len(_meta.permissions) > 0)
super().__init_subclass_with_meta__(arguments=arguments,
_meta=_meta,
**kwargs)
def __init_subclass_with_meta__(cls,
model=None,
registry=None,
only_fields=(),
exclude_fields=None,
**options):
meta = SQLAlchemyMutationOptions(cls)
meta.model = model
model_inspect = sqlalchemyinspect(model)
cls._model_inspect = model_inspect
if not isinstance(exclude_fields, list):
if exclude_fields:
exclude_fields = list(exclude_fields)
else:
exclude_fields = []
for primary_key_column in model_inspect.primary_key:
if primary_key_column.autoincrement:
exclude_fields.append(primary_key_column.name)
for relationship in model_inspect.relationships:
exclude_fields.append(relationship.key)
if not registry:
registry = get_global_registry()
arguments = yank_fields_from_attrs(
construct_fields(model, registry, only_fields, exclude_fields),
_as=Argument,
)
super(SQLAlchemyCreate,
cls).__init_subclass_with_meta__(_meta=meta,
arguments=arguments,
**options)
def __init_subclass_with_meta__(
cls,
model=None,
registry=None,
skip_registry=False,
only_fields=(),
exclude_fields=(),
connection=None,
connection_class=None,
use_connection=None,
interfaces=(),
id=None,
connection_field_factory=default_connection_field_factory,
_meta=None,
**options):
if not registry:
registry = get_global_registry()
assert isinstance(registry, Registry), (
"The attribute registry in {} needs to be an instance of "
'Registry, received "{}".').format(cls.__name__, registry)
if only_fields and exclude_fields:
raise ValueError(
"The options 'only_fields' and 'exclude_fields' cannot be both set on the same type."
)
sqla_fields = yank_fields_from_attrs(
construct_fields(
obj_type=cls,
model=model,
registry=registry,
only_fields=only_fields,
exclude_fields=exclude_fields,
connection_field_factory=connection_field_factory,
),
_as=Field,
sort=False,
)
if use_connection is None and interfaces:
use_connection = any(
(issubclass(interface, Node) for interface in interfaces))
if use_connection and not connection:
# We create the connection automatically
if not connection_class:
connection_class = Connection
connection = connection_class.create_type("{}Connection".format(
cls.__name__),
node=cls)
if connection is not None:
assert issubclass(connection, Connection), (
"The connection must be a Connection. Received {}").format(
connection.__name__)
if not _meta:
_meta = SQLAlchemyObjectTypeOptions(cls)
_meta.model = model
_meta.registry = registry
if _meta.fields:
_meta.fields.update(sqla_fields)
else:
_meta.fields = sqla_fields
_meta.connection = connection
_meta.id = id or "id"
super(SQLAlchemyObjectType,
cls).__init_subclass_with_meta__(_meta=_meta,
interfaces=interfaces,
**options)
if not skip_registry:
registry.register(cls)
def __init_subclass_with_meta__(
cls,
_meta=None,
model=None,
permissions=None,
login_required=None,
only_fields=(),
exclude_fields=(),
optional_fields=(),
required_fields=(),
auto_context_fields={},
return_field_name=None,
many_to_many_extras=None,
foreign_key_extras=None,
many_to_one_extras=None,
one_to_one_extras=None,
type_name=None,
field_types=None,
ignore_primary_key=True,
custom_fields=None,
**kwargs,
):
registry = get_global_registry()
meta_registry = get_type_meta_registry()
model_type = registry.get_type_for_model(model)
if auto_context_fields is None:
auto_context_fields = {}
if many_to_one_extras is None:
many_to_one_extras = {}
if foreign_key_extras is None:
foreign_key_extras = {}
if many_to_many_extras is None:
many_to_many_extras = {}
if one_to_one_extras is None:
one_to_one_extras = {}
if custom_fields is None:
custom_fields = {}
assert model_type, f"Model type must be registered for model {model}"
if not return_field_name:
return_field_name = to_snake_case(model.__name__)
input_type_name = type_name or f"Create{model.__name__}Input"
model_fields = get_input_fields_for_model(
model,
only_fields,
exclude_fields,
tuple(auto_context_fields.keys()) + optional_fields,
required_fields,
many_to_many_extras,
foreign_key_extras,
many_to_one_extras,
one_to_one_extras=one_to_one_extras,
parent_type_name=input_type_name,
field_types=field_types,
ignore_primary_key=ignore_primary_key,
)
for name, field in custom_fields.items():
model_fields[name] = field
InputType = type(input_type_name, (InputObjectType, ), model_fields)
# Register meta-data
meta_registry.register(
input_type_name,
{
"auto_context_fields": auto_context_fields or {},
"optional_fields": optional_fields,
"required_fields": required_fields,
"many_to_many_extras": many_to_many_extras,
"many_to_one_extras": many_to_one_extras,
"foreign_key_extras": foreign_key_extras,
"one_to_one_extras": one_to_one_extras,
"field_types": field_types or {},
},
)
registry.register_converted_field(input_type_name, InputType)
arguments = OrderedDict(input=InputType(required=True))
output_fields = OrderedDict()
output_fields[return_field_name] = graphene.Field(model_type)
if _meta is None:
_meta = DjangoCreateMutationOptions(cls)
_meta.model = model
_meta.fields = yank_fields_from_attrs(output_fields,
_as=graphene.Field)
_meta.return_field_name = return_field_name
_meta.optional_fields = optional_fields
_meta.required_fields = required_fields
_meta.permissions = permissions
_meta.auto_context_fields = auto_context_fields
_meta.many_to_many_extras = many_to_many_extras
_meta.many_to_one_extras = many_to_one_extras
_meta.foreign_key_extras = foreign_key_extras
_meta.one_to_one_extras = one_to_one_extras
_meta.field_types = field_types or {}
_meta.InputType = InputType
_meta.input_type_name = input_type_name
_meta.login_required = login_required or (_meta.permissions and
len(_meta.permissions) > 0)
super().__init_subclass_with_meta__(arguments=arguments,
_meta=_meta,
**kwargs)
def __init_subclass_with_meta__(cls,
model=None,
registry=None,
skip_registry=False,
only_fields=(),
exclude_fields=(),
filter_fields=None,
connection=None,
connection_class=None,
use_connection=None,
interfaces=(),
_meta=None,
**options):
assert is_valid_django_model(model), (
'You need to pass a valid Django Model in {}.Meta, received "{}".'
).format(cls.__name__, model)
if not registry:
registry = get_global_registry()
assert isinstance(registry, Registry), (
'The attribute registry in {} needs to be an instance of '
'Registry, received "{}".').format(cls.__name__, registry)
if not DJANGO_FILTER_INSTALLED and filter_fields:
raise Exception(
"Can only set filter_fields if Django-Filter is installed")
django_fields = yank_fields_from_attrs(
construct_fields(model, registry, only_fields, exclude_fields),
_as=Field,
)
if use_connection is None and interfaces:
use_connection = any(
(issubclass(interface, Node) for interface in interfaces))
if use_connection and not connection:
# We create the connection automatically
if not connection_class:
connection_class = Connection
connection = connection_class.create_type('{}Connection'.format(
cls.__name__),
node=cls)
if connection is not None:
assert issubclass(connection, Connection), (
"The connection must be a Connection. Received {}").format(
connection.__name__)
if not _meta:
_meta = DjangoObjectTypeOptions(cls)
_meta.model = model
_meta.registry = registry
_meta.filter_fields = filter_fields
_meta.fields = django_fields
_meta.connection = connection
super(DjangoObjectType,
cls).__init_subclass_with_meta__(_meta=_meta,
interfaces=interfaces,
**options)
if not skip_registry:
registry.register(cls)
def __init_subclass_with_meta__(
cls,
model: type = None,
registry: Registry = None,
skip_registry: bool = False,
only_fields: T.Tuple[str, ...] = (),
exclude_fields: T.Tuple[str, ...] = (),
interfaces=(),
id=None,
_meta=None,
**options,
):
assert model and issubclass(
model, pydantic.BaseModel
), f'You need to pass a valid Pydantic model in {cls.__name__}.Meta, received "{model}"'
assert isinstance(
registry, (Registry, None.__class__)
), f'The attribute registry in {cls.__name__} needs to be an instance of Registry, received "{registry}".'
if only_fields and exclude_fields:
raise ValueError(
"The options 'only_fields' and 'exclude_fields' cannot be both set on the same type."
)
if not registry:
registry = get_global_registry(PydanticObjectType)
pydantic_fields = yank_fields_from_attrs(
construct_fields(
obj_type=cls,
model=model,
registry=registry,
only_fields=only_fields,
exclude_fields=exclude_fields,
),
_as=graphene.Field,
sort=False,
)
if not _meta:
_meta = PydanticObjectTypeOptions(cls)
_meta.model = model
_meta.registry = registry
if _meta.fields:
_meta.fields.update(pydantic_fields)
else:
_meta.fields = pydantic_fields
_meta.id = id or "id"
# TODO: We don't currently do anything with interfaces, and it would
# be great to handle them as well. Some options include:
# - throwing an error if they're present, because we _can't_ handle them
# - finding a model class with that name and generating an interface
# from it
# - using the nearest common ancestor of multiple types in a Union
super().__init_subclass_with_meta__(_meta=_meta,
interfaces=interfaces,
**options)
if not skip_registry:
registry.register(cls)
def __init_subclass_with_meta__(cls,
model=None,
registry=None,
skip_registry=False,
only_fields=(),
exclude_fields=(),
connection=None,
connection_class=None,
use_connection=None,
interfaces=(),
id=None,
_meta=None,
**options):
assert is_mapped_class(model), (
"You need to pass a valid SQLAlchemy Model in "
'{}.Meta, received "{}".').format(cls.__name__, model)
if not registry:
registry = get_global_registry()
assert isinstance(registry, Registry), (
"The attribute registry in {} needs to be an instance of "
'Registry, received "{}".').format(cls.__name__, registry)
sqla_fields = yank_fields_from_attrs(construct_fields(
model, registry, only_fields, exclude_fields),
_as=Field)
if use_connection is None and interfaces:
use_connection = any(
(issubclass(interface, Node) for interface in interfaces))
if use_connection and not connection:
# We create the connection automatically
if not connection_class:
connection_class = Connection
connection = connection_class.create_type("{}Connection".format(
cls.__name__),
node=cls)
if connection is not None:
assert issubclass(connection, Connection), (
"The connection must be a Connection. Received {}").format(
connection.__name__)
if not _meta:
_meta = SQLAlchemyObjectTypeOptions(cls)
_meta.model = model
_meta.registry = registry
if _meta.fields:
_meta.fields.update(sqla_fields)
else:
_meta.fields = sqla_fields
_meta.connection = connection
_meta.id = id or "id"
super(SQLAlchemyObjectType,
cls).__init_subclass_with_meta__(_meta=_meta,
interfaces=interfaces,
**options)
if not skip_registry:
registry.register(cls)
def __init_subclass_with_meta__(
cls,
model=None,
registry=None,
skip_registry=False,
only_fields=None, # deprecated in favour of `fields`
fields=None,
exclude_fields=None, # deprecated in favour of `exclude`
exclude=None,
filter_fields=None,
filterset_class=None,
connection=None,
connection_class=None,
use_connection=None,
interfaces=(),
convert_choices_to_enum=True,
_meta=None,
**options):
assert is_valid_django_model(model), (
'You need to pass a valid Django Model in {}.Meta, received "{}".'
).format(cls.__name__, model)
if not registry:
registry = get_global_registry()
assert isinstance(registry, Registry), (
"The attribute registry in {} needs to be an instance of "
'Registry, received "{}".').format(cls.__name__, registry)
if filter_fields and filterset_class:
raise Exception("Can't set both filter_fields and filterset_class")
if not DJANGO_FILTER_INSTALLED and (filter_fields or filterset_class):
raise Exception(
("Can only set filter_fields or filterset_class if "
"Django-Filter is installed"))
assert not (fields and exclude), (
"Cannot set both 'fields' and 'exclude' options on "
"DjangoObjectType {class_name}.".format(class_name=cls.__name__))
# Alias only_fields -> fields
if only_fields and fields:
raise Exception("Can't set both only_fields and fields")
if only_fields:
warnings.warn(
"Defining `only_fields` is deprecated in favour of `fields`.",
PendingDeprecationWarning,
stacklevel=2,
)
fields = only_fields
if fields and fields != ALL_FIELDS and not isinstance(
fields, (list, tuple)):
raise TypeError(
'The `fields` option must be a list or tuple or "__all__". '
"Got %s." % type(fields).__name__)
# Alias exclude_fields -> exclude
if exclude_fields and exclude:
raise Exception("Can't set both exclude_fields and exclude")
if exclude_fields:
warnings.warn(
"Defining `exclude_fields` is deprecated in favour of `exclude`.",
PendingDeprecationWarning,
stacklevel=2,
)
exclude = exclude_fields
if exclude and not isinstance(exclude, (list, tuple)):
raise TypeError(
"The `exclude` option must be a list or tuple. Got %s." %
type(exclude).__name__)
django_fields = yank_fields_from_attrs(
construct_fields(model, registry, fields, exclude,
convert_choices_to_enum),
_as=Field,
)
if use_connection is None and interfaces:
use_connection = any(
(issubclass(interface, Node) for interface in interfaces))
if use_connection and not connection:
# We create the connection automatically
if not connection_class:
connection_class = Connection
connection = connection_class.create_type("{}Connection".format(
cls.__name__),
node=cls)
if connection is not None:
assert issubclass(connection, Connection), (
"The connection must be a Connection. Received {}").format(
connection.__name__)
if not _meta:
_meta = DjangoObjectTypeOptions(cls)
_meta.model = model
_meta.registry = registry
_meta.filter_fields = filter_fields
_meta.filterset_class = filterset_class
_meta.fields = django_fields
_meta.connection = connection
super(DjangoObjectType,
cls).__init_subclass_with_meta__(_meta=_meta,
interfaces=interfaces,
**options)
# Validate fields
validate_fields(cls, model, _meta.fields, fields, exclude)
if not skip_registry:
registry.register(cls)
def __init_subclass_with_meta__(
cls,
_meta=None,
model=None,
permissions=None,
login_required=None,
filter_fields=(),
filter_class=None,
type_name=None,
only_fields=(),
exclude_fields=(),
optional_fields=None,
required_fields=(),
field_types=None,
auto_context_fields={},
**kwargs,
):
registry = get_global_registry()
model_type = registry.get_type_for_model(model)
if optional_fields is None:
optional_fields = tuple(name
for name, _ in get_model_fields(model))
assert model_type, f"Model type must be registered for model {model}"
assert (
len(filter_fields) > 0
), f"You must specify at least one field to filter on for deletion."
input_arguments = get_filter_fields_input_args(filter_fields, model)
FilterInputType = type(
f"FilterUpdate{model.__name__}FilterInput",
(InputObjectType, ),
input_arguments,
)
input_type_name = type_name or f"FilterUpdate{model.__name__}DataInput"
model_fields = get_input_fields_for_model(
model,
only_fields,
exclude_fields,
tuple(auto_context_fields.keys()) + optional_fields,
required_fields,
None,
None,
None,
one_to_one_extras=None,
parent_type_name=input_type_name,
field_types=field_types,
ignore_primary_key=True,
)
DataInputType = type(input_type_name, (InputObjectType, ),
model_fields)
# Register meta-data
meta_registry.register(
input_type_name,
{
"auto_context_fields": auto_context_fields or {},
"optional_fields": optional_fields,
"required_fields": required_fields,
"many_to_many_extras": {},
"many_to_one_extras": {},
"foreign_key_extras": {},
"one_to_one_extras": {},
"field_types": field_types or {},
},
)
registry.register_converted_field(input_type_name, DataInputType)
arguments = OrderedDict(filter=FilterInputType(required=True),
data=DataInputType(required=True))
output_fields = OrderedDict()
output_fields["updated_count"] = graphene.Int()
output_fields["updated_objects"] = graphene.List(model_type)
if _meta is None:
_meta = DjangoFilterUpdateMutationOptions(cls)
_meta.model = model
_meta.fields = yank_fields_from_attrs(output_fields,
_as=graphene.Field)
_meta.filter_fields = filter_fields
_meta.permissions = permissions
_meta.login_required = login_required or (_meta.permissions and
len(_meta.permissions) > 0)
super().__init_subclass_with_meta__(arguments=arguments,
_meta=_meta,
**kwargs)
def __init_subclass_with_meta__(
cls,
model=None,
registry=None,
skip_registry=False,
only_fields=(),
exclude_fields=(),
connection=None,
connection_class=None,
use_connection=None,
interfaces=(),
id=None,
connection_field_factory=default_connection_field_factory,
_meta=None,
**options,
):
autoexclude = []
# always pull ids out to a separate argument
for col in sqlalchemy.inspect(model).columns:
if (col.primary_key and col.autoincrement) or (
isinstance(col.type, sqlalchemy.types.TIMESTAMP)
and col.server_default is not None):
autoexclude.append(col.name)
if not registry:
registry = get_global_registry()
sqla_fields = yank_fields_from_attrs(
construct_fields(
cls,
model,
registry,
only_fields,
exclude_fields + tuple(autoexclude),
connection_field_factory,
),
_as=Field,
)
# create accessor for model to be retrieved for querying
cls.sqla_model = model
if use_connection is None and interfaces:
use_connection = any(
(issubclass(interface, Node) for interface in interfaces))
if use_connection and not connection:
# We create the connection automatically
if not connection_class:
connection_class = Connection
connection = connection_class.create_type("{}Connection".format(
cls.__name__),
node=cls)
if connection is not None:
assert issubclass(connection, Connection), (
"The connection must be a Connection. Received {}").format(
connection.__name__)
for key, value in sqla_fields.items():
if not (isinstance(value, Dynamic) or hasattr(cls, key)):
setattr(cls, key, value)
super(SQLAlchemyInputObjectType,
cls).__init_subclass_with_meta__(**options)
def __init_subclass_with_meta__(
cls,
model=None,
max_limit=None,
only_fields="__all__",
exclude_fields=(),
input_only_fields="__all__",
input_exclude_fields=(),
input_extend_fields=(),
where_only_fields="__all__",
where_exclude_fields=(),
order_by_only_fields="__all__",
order_by_exclude_fields=(),
validator=True,
validator_exclude=None,
validator_validate_unique=True,
description="",
connection=None,
connection_class=None,
use_connection=True,
interfaces=(),
registry=None,
skip_registry=False,
_meta=None,
**options,
):
if not model:
raise Exception("model is required on all DjangoCRUDObjectType")
if not registry:
registry = get_global_registry()
assert isinstance(registry, Registry), (
"The attribute registry in {} needs to be an instance of "
'Registry, received "{}".').format(cls.__name__, registry)
description = description or "type for {} model".format(model.__name__)
fields = yank_fields_from_attrs(
construct_fields(model, registry, only_fields, exclude_fields),
_as=graphene.Field,
)
use_relay = False
if interfaces:
use_relay = any(
(issubclass(interface, Node) for interface in interfaces))
if use_relay and not use_connection:
use_connection = True
if use_connection and not connection:
# We create the connection automatically
if not connection_class:
if use_relay:
connection_class = RelayConnection
else:
connection_class = DefaultConnection
connection = connection_class.create_type("{}Connection".format(
options.get("name") or cls.__name__),
node=cls)
if not _meta:
_meta = DjangoCRUDObjectTypeOptions(cls)
_meta.model = model
_meta.max_limit = max_limit
_meta.fields = fields
_meta.only_fields = only_fields
_meta.exclude_fields = exclude_fields
_meta.input_only_fields = input_only_fields
_meta.input_exclude_fields = input_exclude_fields
_meta.input_extend_fields = input_extend_fields
_meta.where_only_fields = where_only_fields
_meta.where_exclude_fields = where_exclude_fields
_meta.order_by_only_fields = order_by_only_fields
_meta.order_by_exclude_fields = order_by_exclude_fields
_meta.validator = validator
_meta.validator_exclude = validator_exclude
_meta.validator_validate_unique = validator_validate_unique
_meta.connection = connection
_meta.connection_class = connection_class
_meta.use_connection = use_connection
_meta.registry = registry
super(DjangoCRUDObjectType,
cls).__init_subclass_with_meta__(_meta=_meta,
interfaces=interfaces,
description=description,
**options)
if not skip_registry:
registry.register_django_type(cls)
def __init_subclass_with_meta__(
cls,
model=None,
permissions=None,
login_required=None,
only_fields=(),
exclude_fields=(),
optional_fields=(),
required_fields=(),
auto_context_fields={},
return_field_name=None,
many_to_many_extras=None,
foreign_key_extras=None,
many_to_one_extras=None,
type_name=None,
use_type_name=None,
**kwargs,
):
registry = get_global_registry()
meta_registry = get_type_meta_registry()
model_type = registry.get_type_for_model(model)
if many_to_one_extras is None:
many_to_one_extras = {}
if foreign_key_extras is None:
foreign_key_extras = {}
if many_to_many_extras is None:
many_to_many_extras = {}
assert model_type, f"Model type must be registered for model {model}"
if not return_field_name:
# Pluralize
return_field_name = to_snake_case(model.__name__) + "s"
if use_type_name:
input_type_name = use_type_name
InputType = registry.get_converted_field(input_type_name)
if not InputType:
raise GraphQLError(
f"Could not find input type with name {input_type_name}")
else:
input_type_name = type_name or f"BatchCreate{model.__name__}Input"
model_fields = get_input_fields_for_model(
model,
only_fields,
exclude_fields,
tuple(auto_context_fields.keys()) + optional_fields,
required_fields,
many_to_many_extras,
foreign_key_extras,
many_to_one_extras,
parent_type_name=input_type_name,
)
InputType = type(input_type_name, (InputObjectType, ),
model_fields)
# Register meta-data
meta_registry.register(
input_type_name, {
'auto_context_fields': auto_context_fields or {},
'optional_fields': optional_fields,
'required_fields': required_fields,
'many_to_many_extras': many_to_many_extras or {},
'foreign_key_extras': foreign_key_extras or {}
})
registry.register_converted_field(input_type_name, InputType)
arguments = OrderedDict(input=graphene.List(InputType, required=True))
output_fields = OrderedDict()
output_fields[return_field_name] = graphene.List(model_type)
_meta = DjangoBatchCreateMutationOptions(cls)
_meta.model = model
_meta.fields = yank_fields_from_attrs(output_fields,
_as=graphene.Field)
_meta.return_field_name = return_field_name
_meta.optional_fields = optional_fields
_meta.required_fields = required_fields
_meta.permissions = permissions
_meta.auto_context_fields = auto_context_fields or {}
_meta.many_to_many_extras = many_to_many_extras or {}
_meta.foreign_key_extras = foreign_key_extras
_meta.many_to_one_extras = many_to_one_extras or {}
_meta.InputType = InputType
_meta.input_type_name = input_type_name
_meta.login_required = _meta.login_required or (
_meta.permissions and len(_meta.permissions) > 0)
super().__init_subclass_with_meta__(arguments=arguments,
_meta=_meta,
**kwargs)
def __init_subclass_with_meta__(
cls,
model=None,
permissions=None,
login_required=None,
only_fields=(),
exclude_fields=(),
return_field_name=None,
auto_context_fields={},
many_to_one_extras=None,
many_to_many_extras=None,
foreign_key_extras=None,
type_name=None,
**kwargs,
):
registry = get_global_registry()
meta_registry = get_type_meta_registry()
model_type = registry.get_type_for_model(model)
assert model_type, f"Model type must be registered for model {model}"
if not return_field_name:
return_field_name = to_snake_case(model.__name__)
if many_to_one_extras is None:
many_to_one_extras = {}
if foreign_key_extras is None:
foreign_key_extras = {}
if many_to_many_extras is None:
many_to_many_extras = {}
input_type_name = type_name or f"Patch{model.__name__}Input"
model_fields = get_all_optional_input_fields_for_model(
model,
only_fields,
exclude_fields,
many_to_many_extras=many_to_many_extras,
foreign_key_extras=foreign_key_extras,
many_to_one_extras=many_to_one_extras,
parent_type_name=type_name,
)
InputType = type(input_type_name, (InputObjectType, ), model_fields)
# Register meta-data
meta_registry.register(
input_type_name, {
'auto_context_fields': auto_context_fields or {},
'many_to_many_extras': many_to_many_extras or {},
'many_to_one_extras': many_to_one_extras or {},
'foreign_key_extras': foreign_key_extras or {}
})
registry.register_converted_field(input_type_name, InputType)
arguments = OrderedDict(id=graphene.ID(required=True),
input=InputType(required=True))
output_fields = OrderedDict()
output_fields[return_field_name] = graphene.Field(model_type)
_meta = DjangoPatchMutationOptions(cls)
_meta.model = model
_meta.fields = yank_fields_from_attrs(output_fields,
_as=graphene.Field)
_meta.return_field_name = return_field_name
_meta.permissions = permissions
_meta.auto_context_fields = auto_context_fields or {}
_meta.InputType = InputType
_meta.input_type_name = input_type_name
_meta.many_to_many_extras = many_to_many_extras
_meta.many_to_one_extras = many_to_one_extras
_meta.foreign_key_extras = foreign_key_extras
_meta.login_required = _meta.login_required or (
_meta.permissions and len(_meta.permissions) > 0)
super().__init_subclass_with_meta__(arguments=arguments,
_meta=_meta,
**kwargs)
def __init_subclass_with_meta__(
cls,
model: DeclarativeMeta = None,
registry: Registry = None,
only_fields: Tuple[str] = (),
exclude_fields: Tuple[str] = (),
connection_field_factory:
UnsortedSQLAlchemyConnectionField = default_connection_field_factory,
skip_registry: Optional[bool] = False,
**options,
):
_meta = SQLAlchemyInterfaceOptions(cls)
_meta.name = f"{cls.__name__}Node"
autoexclude_columns = exclude_autogenerated_sqla_columns(model=model)
exclude_fields += autoexclude_columns
assert is_mapped_class(model), (
"You need to pass a valid SQLAlchemy Model in "
'{}.Meta, received "{}".').format(cls.__name__, model)
if not registry:
registry = get_global_registry()
assert isinstance(registry, Registry), (
"The attribute registry in {} needs to be an instance of "
'Registry, received "{}".').format(cls.__name__, registry)
from .types import construct_fields
sqla_fields = yank_fields_from_attrs(
construct_fields(
obj_type=cls,
model=model,
registry=registry,
only_fields=only_fields,
exclude_fields=exclude_fields,
connection_field_factory=connection_field_factory,
),
_as=Field,
)
if not _meta:
_meta = SQLAlchemyInterfaceOptions(cls)
_meta.model = model
_meta.registry = registry
connection = Connection.create_type("{}Connection".format(
cls.__name__),
node=cls)
assert issubclass(connection, Connection), (
"The connection must be a Connection. Received {}").format(
connection.__name__)
_meta.connection = connection
if _meta.fields:
_meta.fields.update(sqla_fields)
else:
_meta.fields = sqla_fields
_meta.fields["id"] = graphene.GlobalID(
cls, description="The ID of the object.")
# call super of AbstractNode directly because it creates its own _meta, which we don't want
super(AbstractNode, cls).__init_subclass_with_meta__(_meta=_meta,
**options)
if not skip_registry:
registry.register(cls)
def __init_subclass_with_meta__(cls,
model=None,
registry=None,
skip_registry=False,
only_fields=(),
exclude_fields=(),
connection=None,
use_connection=None,
interfaces=(),
**options):
if not model:
raise Exception((
'NdbObjectType {name} must have a model in the Meta class attr'
).format(name=cls.__name__))
if not inspect.isclass(model) or not issubclass(model, ndb.Model):
raise Exception(
('Provided model in {name} is not an NDB model').format(
name=cls.__name__))
if not registry:
registry = get_global_registry()
assert isinstance(registry, Registry), (
'The attribute registry in {} needs to be an instance of '
'Registry, received "{}".').format(cls.__name__, registry)
ndb_fields = fields_for_ndb_model(model, registry, only_fields,
exclude_fields)
ndb_fields = yank_fields_from_attrs(
ndb_fields,
_as=Field,
)
if use_connection is None and interfaces:
use_connection = any(
(issubclass(interface, Node) for interface in interfaces))
if use_connection and not connection:
# We create the connection automatically
connection = Connection.create_type('{}Connection'.format(
cls.__name__),
node=cls)
if connection is not None:
assert issubclass(connection, Connection), (
"The connection must be a Connection. Received {}").format(
connection.__name__)
_meta = NdbObjectTypeOptions(cls)
_meta.model = model
_meta.registry = registry
_meta.fields = ndb_fields
_meta.connection = connection
super(NdbObjectType,
cls).__init_subclass_with_meta__(_meta=_meta,
interfaces=interfaces,
**options)
if not skip_registry:
registry.register(cls)
def __init_subclass_with_meta__(cls,
model=None,
registry=None,
skip_registry=False,
only_fields=(),
exclude_fields=(),
filter_fields=None,
connection=None,
connection_class=None,
use_connection=None,
interfaces=(),
**options):
assert is_valid_mongoengine_model(model), (
'You need to pass a valid Mongoengine Model in {}.Meta, received "{}".'
).format(cls.__name__, model)
if not registry:
registry = get_global_registry()
assert isinstance(registry, Registry), (
'The attribute registry in {} needs to be an instance of '
'Registry, received "{}".').format(cls.__name__, registry)
converted_fields, self_referenced = construct_fields(
model, registry, only_fields, exclude_fields)
mongoengine_fields = yank_fields_from_attrs(converted_fields,
_as=Field)
if use_connection is None and interfaces:
use_connection = any(
(issubclass(interface, Node) for interface in interfaces))
if use_connection and not connection:
# We create the connection automatically
if not connection_class:
connection_class = Connection
connection = connection_class.create_type('{}Connection'.format(
cls.__name__),
node=cls)
if connection is not None:
assert issubclass(connection, Connection), (
'The connection must be a Connection. Received {}').format(
connection.__name__)
_meta = MongoengineObjectTypeOptions(cls)
_meta.model = model
_meta.registry = registry
_meta.fields = mongoengine_fields
_meta.filter_fields = filter_fields
_meta.connection = connection
super(MongoengineObjectType,
cls).__init_subclass_with_meta__(_meta=_meta,
interfaces=interfaces,
**options)
if not skip_registry:
registry.register(cls)
# Notes: Take care list of self-reference fields.
converted_fields = construct_self_referenced_fields(
self_referenced, registry)
if converted_fields:
mongoengine_fields = yank_fields_from_attrs(converted_fields,
_as=Field)
cls._meta.fields.update(mongoengine_fields)
registry.register(cls)
def __init_subclass_with_meta__(cls,
document=None,
registry=None,
skip_registry=False,
only_fields=(),
exclude_fields=(),
connection=None,
connection_class=None,
use_connection=None,
connection_field_class=None,
interfaces=(),
_meta=None,
**options):
assert is_valid_elasticsearch_document(document), (
'The attribute document in {}.Meta must be a valid '
'Elasticsearch-dsl Document. Received "{}" instead.').format(
cls.__name__, type(document))
if not registry:
registry = get_global_registry()
assert isinstance(registry, Registry), (
'The attribute registry in {}.Meta needs to be an instance of '
'Registry, received "{}".').format(cls.__name__, registry)
converted_fields, self_referenced = construct_fields(
document, registry, only_fields, exclude_fields)
document_fields = yank_fields_from_attrs(converted_fields,
_as=graphene.Field)
if use_connection is None and interfaces:
use_connection = any(
(issubclass(interface, Node) for interface in interfaces))
if use_connection and not connection:
# We create the connection automatically
if not connection_class:
connection_class = Connection
connection = connection_class.create_type('{}Connection'.format(
cls.__name__),
node=cls)
if connection is not None:
assert issubclass(connection, Connection), (
'The attribute connection in {}.Meta must be of type '
'Connection. Received "{}" instead.').format(
cls.__name__, type(connection))
if connection_field_class is not None:
assert issubclass(
connection_field_class, graphene.ConnectionField
), ('The attribute connection_field_class in {}.Meta must be of '
'type graphene.ConnectionField. Received "{}" instead.'
).format(cls.__name__, type(connection_field_class))
else:
from ..fields import ElasticsearchConnectionField
connection_field_class = ElasticsearchConnectionField
if _meta:
assert isinstance(_meta, ElasticsearchObjectTypeOptions), (
'_meta must be an instance of ElasticsearchObjectTypeOptions, '
'received {}').format(_meta.__class__)
else:
_meta = ElasticsearchObjectTypeOptions(cls)
backend_fields = construct_backend_fields(backends=options.get(
'filter_backends', []),
connection=connection)
document_fields.update(backend_fields)
_meta.document = document
_meta.registry = registry
_meta.fields = document_fields
_meta.filter_backends = options.get('filter_backends', [])
_meta.filter_backend_options = dict(options)
_meta.connection = connection
_meta.connection_field_class = connection_field_class
# Save them for later
_meta.only_fields = only_fields
_meta.exclude_fields = exclude_fields
super(ElasticsearchObjectType,
cls).__init_subclass_with_meta__(_meta=_meta,
interfaces=interfaces,
**options)
if not skip_registry:
registry.register(cls)
# Notes: Take care list of self-reference fields.
converted_fields = construct_self_referenced_fields(
self_referenced, registry)
if converted_fields:
document_fields = yank_fields_from_attrs(converted_fields,
_as=graphene.Field)
cls._meta.fields.update(document_fields)
registry.register(cls)
def __init_subclass_with_meta__(cls,
model=None,
registry=None,
skip_registry=False,
only_fields=(),
exclude_fields=(),
filter_fields=None,
connection=None,
connection_class=None,
use_connection=None,
connection_field_class=None,
interfaces=(),
_meta=None,
**options):
assert is_valid_mongoengine_model(model), (
"The attribute model in {}.Meta must be a valid Mongoengine Model. "
'Received "{}" instead.').format(cls.__name__, type(model))
if not registry:
registry = get_global_registry()
assert isinstance(registry, Registry), (
"The attribute registry in {}.Meta needs to be an instance of "
'Registry, received "{}".').format(cls.__name__, registry)
converted_fields, self_referenced = construct_fields(
model, registry, only_fields, exclude_fields)
mongoengine_fields = yank_fields_from_attrs(converted_fields,
_as=graphene.Field)
if use_connection is None and interfaces:
use_connection = any(
(issubclass(interface, Node) for interface in interfaces))
if use_connection and not connection:
# We create the connection automatically
if not connection_class:
connection_class = Connection
connection = connection_class.create_type("{}Connection".format(
cls.__name__),
node=cls)
if connection is not None:
assert issubclass(connection, Connection), (
"The attribute connection in {}.Meta must be of type Connection. "
'Received "{}" instead.').format(cls.__name__,
type(connection))
if connection_field_class is not None:
assert issubclass(
connection_field_class, graphene.ConnectionField
), ("The attribute connection_field_class in {}.Meta must be of type graphene.ConnectionField. "
'Received "{}" instead.').format(cls.__name__,
type(connection_field_class))
else:
connection_field_class = MongoengineConnectionField
if _meta:
assert isinstance(_meta, MongoengineObjectTypeOptions), (
"_meta must be an instance of MongoengineObjectTypeOptions, "
"received {}").format(_meta.__class__)
else:
_meta = MongoengineObjectTypeOptions(cls)
_meta.model = model
_meta.registry = registry
_meta.fields = mongoengine_fields
_meta.filter_fields = filter_fields
_meta.connection = connection
_meta.connection_field_class = connection_field_class
# Save them for later
_meta.only_fields = only_fields
_meta.exclude_fields = exclude_fields
super(MongoengineObjectType,
cls).__init_subclass_with_meta__(_meta=_meta,
interfaces=interfaces,
**options)
if not skip_registry:
registry.register(cls)
# Notes: Take care list of self-reference fields.
converted_fields = construct_self_referenced_fields(
self_referenced, registry)
if converted_fields:
mongoengine_fields = yank_fields_from_attrs(converted_fields,
_as=graphene.Field)
cls._meta.fields.update(mongoengine_fields)
registry.register(cls)
def __init_subclass_with_meta__(
cls,
model=None,
container=None,
registry=None,
skip_registry=False,
connection=None,
use_connection=None,
only_fields=(),
exclude_fields=(),
filter_fields=None,
input_for="create",
nested_fields=(),
**options,
):
assert is_valid_django_model(model), (
'You need to pass a valid Django Model in {}.Meta, received "{}".'
).format(cls.__name__, model)
if not registry:
registry = get_global_registry()
assert isinstance(registry, Registry), (
"The attribute registry in {} needs to be an instance of "
'Registry, received "{}".').format(cls.__name__, registry)
assert input_for.lower not in ("create", "delete", "update"), (
'You need to pass a valid input_for value in {}.Meta, received "{}".'
).format(cls.__name__, input_for)
input_for = input_for.lower()
if not DJANGO_FILTER_INSTALLED and filter_fields:
raise Exception(
"Can only set filter_fields if Django-Filter is installed")
django_input_fields = yank_fields_from_attrs(
construct_fields(
model,
registry,
only_fields,
None,
exclude_fields,
input_for,
nested_fields,
),
_as=InputField,
sort=False,
)
for base in reversed(cls.__mro__):
django_input_fields.update(
yank_fields_from_attrs(base.__dict__, _as=InputField))
if container is None:
container = type(cls.__name__, (InputObjectTypeContainer, cls), {})
_meta = DjangoObjectOptions(cls)
_meta.by_polar = True
_meta.model = model
_meta.registry = registry
_meta.filter_fields = filter_fields
_meta.fields = django_input_fields
_meta.input_fields = django_input_fields
_meta.connection = connection
_meta.input_for = input_for
_meta.container = container
super(InputObjectType, cls).__init_subclass_with_meta__(
# container=container,
_meta=_meta,
**options,
)
if not skip_registry:
registry.register(cls, for_input=input_for)
def __init_subclass_with_meta__(
cls,
lookup_field=None,
serializer_class=None,
model_class=None,
model_operations=["create", "update"],
only_fields=(),
exclude_fields=(),
output_field_name=None,
output_field_type=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
and "delete" not in model_operations):
raise Exception(
'model_operations must contain "create" and/or "update" or "delete"'
)
if "delete" in model_operations and len(model_operations) > 1:
raise Exception(
'model_operations must not contain "create" and/or "update" if "delete" is set'
)
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)
if 'update' in model_operations or 'delete' in model_operations:
input_fields[lookup_field] = graphene.types.scalars.ID()
if not output_field_name:
output_field_name = model_class.__name__.lower()
output_fields = {output_field_name: graphene.Field(output_field_type)}
_meta = GqlModelSerializerMutationOptions(cls)
_meta.lookup_field = lookup_field
_meta.model_operations = model_operations
_meta.serializer_class = serializer_class
_meta.model_class = model_class
_meta.output_field_name = output_field_name
_meta.output_field_type = output_field_type
_meta.fields = yank_fields_from_attrs(output_fields, _as=Field)
input_fields = yank_fields_from_attrs(input_fields, _as=InputField)
super().__init_subclass_with_meta__(_meta=_meta,
input_fields=input_fields,
**options)
