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)