def registry_sqlalchemy_model_from_str(model_name: str) -> Optional[Any]:
try:
return next(
filter(lambda x: x.__name__ == model_name,
list(get_global_registry()._registry.keys())))
except StopIteration:
pass
def _register_composite_class(cls, registry=None):
if registry is None:
# from .registry import get_global_registry
registry = get_global_registry()
def inner(fn):
registry.register_composite_converter(cls, fn)
return inner
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 _construct_union(union_name, models, registry=None):
if registry is None:
registry = get_global_registry()
typs = []
for model in models:
typ = registry.get_type_for_model(model)
if typ:
typs.append(typ)
class Meta:
types = typs
return type(union_name, (Union,), {'Meta': Meta})()
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)
