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) for column in model_inspect.columns: column.nullable = True cls._model_inspect = model_inspect if not isinstance(exclude_fields, list): if exclude_fields: exclude_fields = list(exclude_fields) else: exclude_fields = [] 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(SQLAlchemyListDelete, cls).__init_subclass_with_meta__(_meta=meta, arguments=arguments, **options)
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 only_fields = [] exclude_fields = () for primary_key_column in model_inspect.primary_key: only_fields.append(primary_key_column.name) if not registry: registry = get_global_registry() arguments = yank_fields_from_attrs(construct_fields( model, registry, only_fields, exclude_fields), _as=Argument) super(SQLAlchemyDelete, cls).__init_subclass_with_meta__(_meta=meta, arguments=arguments, **options)
def make_graphene_interface(cls): from graphene.types.utils import yank_fields_from_attrs from graphene import Field, Interface from graphene_sqlalchemy.types import construct_fields, get_global_registry from graphene_sqlalchemy.fields import default_connection_field_factory from graphene_sqlalchemy import SQLAlchemyObjectType name = cls.__name__.replace('Model', '') SqlType = type(name, (SQLAlchemyObjectType,), { 'Meta': type('Meta',(), { 'model': cls , 'interfaces': tuple() })}) fields = yank_fields_from_attrs( construct_fields( obj_type=SqlType, model=cls, registry=get_global_registry(), only_fields=[], exclude_fields=[], connection_field_factory=default_connection_field_factory, ), _as=Field, sort=False, ) return type(f'I{name}', (Interface, ), fields)
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, registry=None, optional_fields=[], 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) for field in model_inspect.all_orm_descriptors: if type(field) == hybrid_property: exclude_fields.append(field.__name__) if not registry: registry = get_global_registry() fields = construct_fields(model, registry, only_fields, exclude_fields) for field_name in optional_fields: if field_name in fields: fields[field_name].kwargs["required"] = False argument_cls = getattr(cls, "Arguments", None) if argument_cls: fields.update(props(argument_cls)) arguments = yank_fields_from_attrs(fields, _as=Argument) super(SQLAlchemyMutation, cls).__init_subclass_with_meta__(_meta=meta, arguments=arguments, **options)
def __init_subclass_with_meta__(cls, model=None, registry=None, only_fields=None, exclude_fields=None, **options): if exclude_fields is None: exclude_fields = [] if only_fields is None: only_fields = [] if not registry: registry = get_global_registry() auto_exclude = [] 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): auto_exclude.append(col.name) sqlalchemy_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 + auto_exclude), connection_field_factory=default_connection_field_factory, batching=True, ), _as=graphene.Field, ) # Add all of the fields to the input type for key, value in sqlalchemy_fields.items(): if not (isinstance(value, Dynamic) or hasattr(cls, key)): if key in foreign_keys: value = graphene.ID(description="graphene global id") setattr(cls, key, value) for key, value in model.__mapper__.relationships.items( ): # many to many input,you should input [dbIds] if isinstance(value.secondary, sqlalchemy.Table): value = graphene.List(graphene.ID) setattr(cls, key, value) super(SQLAlchemyInputObjectType, cls).__init_subclass_with_meta__(**options)
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__(self, type, *args, **kwargs): options = Options( meta=None, # attrs.pop('Meta', None), name=type._meta.name, # name, description=None, # attrs.pop('__doc__', None), model=type._meta.model, # None, local_fields=None, only_fields=(), exclude_fields=('password', 'search_vector'), id='id', interfaces=(), registry=get_global_registry(), fields=(), ) fields = construct_fields(options) for field_name, field_type in fields.items(): if hasattr(field_type, 'kwargs') and 'required' in field_type.kwargs: field_type.kwargs['required'] = False if not isinstance(field_type, Dynamic): # and field_name != 'id': kwargs.setdefault(field_name, field_type) super(FilterableConnectionField, self).__init__(type, *args, **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)