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, )