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)
