def convert_field_to_list(field, registry=None):
base_type = convert_mongoengine_field(field.field, registry=registry)
if isinstance(base_type, graphene.Field):
return graphene.List(base_type._type,
description=get_field_description(
field, registry),
required=field.required)
if isinstance(base_type, (graphene.Dynamic)):
base_type = base_type.get_type()
if base_type is None:
return
base_type = base_type._type
if graphene.is_node(base_type):
return base_type._meta.connection_field_class(base_type)
# Non-relationship field
relations = (mongoengine.ReferenceField, mongoengine.EmbeddedDocumentField)
if not isinstance(base_type,
(graphene.List, graphene.NonNull)) and not isinstance(
field.field, relations):
base_type = type(base_type)
return graphene.List(
base_type,
description=get_field_description(field, registry),
required=field.required,
)
def convert_postgres_array_to_list(field, registry=None):
base_type = convert_mongoengine_field(field.field, registry=registry)
if isinstance(base_type, (Dynamic)):
base_type = base_type.get_type()._type
if is_node(base_type):
return MongoengineConnectionField(base_type)
elif not isinstance(base_type, (List, NonNull)) \
and not isinstance(field.field, mongoengine.ReferenceField):
base_type = type(base_type)
return List(base_type, description=field.db_field, required=not field.null)
def dynamic_type():
_type = registry.get_type_for_model(attribute.model)
if not _type:
return None
if isinstance(attribute, OneToOne):
return Field(_type)
if isinstance(attribute, OneToMany):
if is_node(_type):
return PynamoConnectionField(_type)
return Field(List(_type))
def convert_field_to_list(field, registry=None):
base_type = convert_mongoengine_field(field.field, registry=registry)
if isinstance(base_type, (Dynamic)):
base_type = base_type.get_type()
if base_type is None:
return
base_type = base_type._type
if is_node(base_type):
return MongoengineConnectionField(base_type)
# Non-relationship field
relations = (mongoengine.ReferenceField, mongoengine.EmbeddedDocumentField)
if not isinstance(base_type, (List, NonNull)) \
and not isinstance(field.field, relations):
base_type = type(base_type)
return List(base_type, description=field.db_field, required=not field.null)
def test_object_type():
class Human(SQLAlchemyObjectType):
"""Human description"""
pub_date = Int()
class Meta:
model = Article
# exclude_fields = ('id', )
registry = registry
interfaces = (Node, )
assert issubclass(Human, ObjectType)
assert list(Human._meta.fields.keys()) == [
"id",
"headline",
"pub_date",
"reporter_id",
"reporter",
]
assert is_node(Human)
def convert_field_to_list(field, registry=None):
base_type = convert_mongoengine_field(field.field, registry=registry)
if isinstance(base_type, (graphene.Dynamic)):
base_type = base_type.get_type()
if base_type is None:
return
base_type = base_type._type
if graphene.is_node(base_type):
return base_type._meta.connection_field_class(base_type)
# Non-relationship field
# Here causes some issues
relations = (mongoengine.ReferenceField, mongoengine.EmbeddedDocumentField)
if not isinstance(base_type, (graphene.List, graphene.NonNull)) \
and not isinstance(field.field, relations):
base_type = type(
base_type
) # This line in specifics. It does not allow non-nullable fields. Take, for instance, if base_type was a non nullable string, it would return a plain string.
return graphene.List(base_type,
description=get_field_description(field, registry),
required=field.required)
def convert_pony_field(field, registry=None):
py_type = field.py_type
return_type = None
# ( description=get_field_description(field, registry), required=field.is_required )
if issubclass(py_type, int):
return_type = graphene.Int
if issubclass(py_type, str):
return_type = graphene.String
if issubclass(py_type, float):
return_type = graphene.Float
if issubclass(py_type, bool):
return_type = graphene.Boolean
if issubclass(py_type, date):
return_type = graphene.Date
if issubclass(py_type, datetime):
return_type = graphene.DateTime
if issubclass(py_type, time):
return_type = graphene.Time
if issubclass(py_type, Json):
return_type = graphene.JSONString
if return_type:
return return_type(description=get_field_description(field, registry),
required=field.is_required)
if issubclass(py_type, Entity):
if field.is_collection:
base_type = convert_pony_field(field.field, registry=registry)
if isinstance(base_type, graphene.Field):
return graphene.List(base_type._type,
description=get_field_description(
field, registry),
required=field.required)
elif field.is_relation:
_type = registry.get_type_for_model(py_type)
if not _type:
return None
return graphene.Field(_type,
description=get_field_description(
field, registry))
# if isinstance(py_type, graphene.Field):
# return graphene.List(
# base_type._type,
# description=get_field_description(field, registry),
# required=field.required
# )
# if isinstance(base_type, (graphene.Dynamic)):
# base_type = base_type.get_type()
# if base_type is None:
# return
# base_type = base_type._type
if graphene.is_node(py_type):
return py_type._meta.connection_field_class(py_type)
# Non-relationship field
if not isinstance(
py_type,
(graphene.List, graphene.NonNull)) and not field.is_collection:
return graphene.List(
py_type,
description=get_field_description(field, registry),
required=field.required,
)
def convert_field_to_list(field, registry=None):
base_type = convert_mongoengine_field(field.field, registry=registry)
if isinstance(base_type, graphene.Field):
if isinstance(field.field, mongoengine.GenericReferenceField):
def get_reference_objects(*args, **kwargs):
if args[0][1]:
document = get_document(args[0][0])
document_field = mongoengine.ReferenceField(document)
document_field = convert_mongoengine_field(
document_field, registry)
document_field_type = document_field.get_type(
).type._meta.name
only_fields = [
to_snake_case(i) for i in get_query_fields(
args[0][3][0])[document_field_type].keys()
]
return document.objects().no_dereference().only(
*only_fields).filter(pk__in=args[0][1])
else:
return []
def reference_resolver(root, *args, **kwargs):
choice_to_resolve = dict()
to_resolve = getattr(root, field.name or field.db_name)
if to_resolve:
for each in to_resolve:
if each['_cls'] not in choice_to_resolve:
choice_to_resolve[each['_cls']] = list()
choice_to_resolve[each['_cls']].append(each["_ref"].id)
pool = ThreadPoolExecutor(5)
futures = list()
for model, object_id_list in choice_to_resolve.items():
futures.append(
pool.submit(
get_reference_objects,
(model, object_id_list, registry, args)))
result = list()
for x in as_completed(futures):
result += x.result()
to_resolve_object_ids = [
each["_ref"].id for each in to_resolve
]
result_to_resolve_object_ids = [each.id for each in result]
ordered_result = list()
for each in to_resolve_object_ids:
ordered_result.append(
result[result_to_resolve_object_ids.index(each)])
return ordered_result
return []
return graphene.List(base_type._type,
description=get_field_description(
field, registry),
required=field.required,
resolver=reference_resolver)
return graphene.List(base_type._type,
description=get_field_description(
field, registry),
required=field.required)
if isinstance(base_type, (graphene.Dynamic)):
base_type = base_type.get_type()
if base_type is None:
return
base_type = base_type._type
if graphene.is_node(base_type):
return base_type._meta.connection_field_class(base_type)
# Non-relationship field
relations = (mongoengine.ReferenceField, mongoengine.EmbeddedDocumentField)
if not isinstance(base_type,
(graphene.List, graphene.NonNull)) and not isinstance(
field.field, relations):
base_type = type(base_type)
return graphene.List(
base_type,
description=get_field_description(field, registry),
required=field.required,
)
def convert_field_to_list(field, registry=None):
base_type = convert_mongoengine_field(field.field, registry=registry)
if isinstance(base_type, graphene.Field):
if isinstance(field.field, mongoengine.GenericReferenceField):
def get_reference_objects(*args, **kwargs):
document = get_document(args[0][0])
document_field = mongoengine.ReferenceField(document)
document_field = convert_mongoengine_field(document_field, registry)
document_field_type = document_field.get_type().type
queried_fields = list()
filter_args = list()
if document_field_type._meta.filter_fields:
for key, values in document_field_type._meta.filter_fields.items():
for each in values:
filter_args.append(key + "__" + each)
for each in get_query_fields(args[0][3][0])[document_field_type._meta.name].keys():
item = to_snake_case(each)
if item in document._fields_ordered + tuple(filter_args):
queried_fields.append(item)
return document.objects().no_dereference().only(
*set(list(document_field_type._meta.required_fields) + queried_fields)).filter(pk__in=args[0][1])
def get_non_querying_object(*args, **kwargs):
model = get_document(args[0][0])
return [model(pk=each) for each in args[0][1]]
def reference_resolver(root, *args, **kwargs):
to_resolve = getattr(root, field.name or field.db_name)
if to_resolve:
choice_to_resolve = dict()
querying_union_types = list(get_query_fields(args[0]).keys())
if '__typename' in querying_union_types:
querying_union_types.remove('__typename')
to_resolve_models = list()
for each in querying_union_types:
to_resolve_models.append(registry._registry_string_map[each])
for each in to_resolve:
if each['_cls'] not in choice_to_resolve:
choice_to_resolve[each['_cls']] = list()
choice_to_resolve[each['_cls']].append(each["_ref"].id)
pool = ThreadPoolExecutor(5)
futures = list()
for model, object_id_list in choice_to_resolve.items():
if model in to_resolve_models:
futures.append(pool.submit(get_reference_objects, (model, object_id_list, registry, args)))
else:
futures.append(
pool.submit(get_non_querying_object, (model, object_id_list, registry, args)))
result = list()
for x in as_completed(futures):
result += x.result()
to_resolve_object_ids = [each["_ref"].id for each in to_resolve]
result_object_ids = list()
for each in result:
result_object_ids.append(each.id)
ordered_result = list()
for each in to_resolve_object_ids:
ordered_result.append(result[result_object_ids.index(each)])
return ordered_result
return None
return graphene.List(
base_type._type,
description=get_field_description(field, registry),
required=field.required,
resolver=reference_resolver
)
return graphene.List(
base_type._type,
description=get_field_description(field, registry),
required=field.required
)
if isinstance(base_type, (graphene.Dynamic)):
base_type = base_type.get_type()
if base_type is None:
return
base_type = base_type._type
if graphene.is_node(base_type):
return base_type._meta.connection_field_class(base_type)
# Non-relationship field
relations = (mongoengine.ReferenceField, mongoengine.EmbeddedDocumentField)
if not isinstance(base_type, (graphene.List, graphene.NonNull)) and not isinstance(
field.field, relations
):
base_type = type(base_type)
return graphene.List(
base_type,
description=get_field_description(field, registry),
required=field.required,
)
