def contribute_to_class(self, cls, name): super(DjangoOptions, self).contribute_to_class(cls, name) if is_node(cls): self.exclude_fields += ['id'] self.interfaces.append(Node) if not is_node(cls) and not is_base(cls): return if not self.model: raise Exception( 'Django ObjectType %s must have a model in the Meta class attr' % cls) elif not inspect.isclass(self.model) or not issubclass(self.model, models.Model): raise Exception('Provided model in %s is not a Django model' % cls)
def internal_type(self, schema): from graphene.relay.utils import is_node node = self.get_object_type(schema) assert is_node(node), 'Only nodes have connections.' schema.register(node) connection_type = self.get_connection_type(node) return schema.T(connection_type)
def _prepare_class(cls): from graphene.relay.utils import is_node if is_node(cls): get_node = getattr(cls, 'get_node') assert get_node, 'get_node classmethod not found in %s Node' % cls assert callable(get_node), 'get_node have to be callable' args = 3 if isinstance(get_node, staticmethod): args -= 1 get_node_num_args = len(inspect.getargspec(get_node).args) if get_node_num_args < args: warnings.warn( "get_node will receive also the info arg" " in future versions of graphene".format(cls.__name__), FutureWarning) @staticmethod @wraps(get_node) def wrapped_node(*node_args): if len(node_args) < args: node_args += (None, ) return get_node(*node_args[:-1]) setattr(cls, 'get_node', wrapped_node)
def object_type_created(object_type): if is_node(object_type): type_name = object_type._meta.type_name field = NodeIDField() object_type.add_to_class('id', field) assert hasattr( object_type, 'get_node'), 'get_node classmethod not found in %s Node' % type_name
def for_node(cls, node): from graphene.relay.utils import is_node assert is_node(node), 'ObjectTypes in a edge have to be Nodes' node_field = Field(node, description='The item at the end of the edge') return type( '%s%s' % (node._meta.type_name, cls._meta.type_name), (cls,), {'node_type': node, 'node': node_field})
def for_node(cls, node, edge_type=None): from graphene.relay.utils import is_node edge_type = edge_type or Edge.for_node(node) assert is_node(node), 'ObjectTypes in a connection have to be Nodes' edges = List(edge_type, description='Information to aid in pagination.') return type( '%s%s' % (node._meta.type_name, cls._meta.type_name), (cls,), {'edge_type': edge_type, 'edges': edges})
def get_type(self, schema): from graphene.relay.utils import is_node type = schema.T(self.type) node = schema.objecttype(type) assert is_node(node), 'Only nodes have connections.' schema.register(node) connection_type = self.get_connection_type(node) return connection_type
def get_field(self, schema): model_field = self.field_type field_object_type = model_field.get_object_type(schema) if is_node(field_object_type): field = DjangoConnectionField(model_field) else: field = LazyListField(model_field) field.contribute_to_class(self.object_type, self.name) return field
def internal_type(self, schema): document_field = self.type field_object_type = document_field.get_object_type(schema) if not field_object_type: raise SkipField() if is_node(field_object_type): field = MongoEngineConnectionField(field_object_type) else: field = Field(List(field_object_type)) field.contribute_to_class(self.object_type, self.attname) return schema.T(field)
def id_fetcher(self, global_id, info): from graphene.relay.utils import is_node schema = info.schema.graphene_schema resolved_global_id = from_global_id(global_id) _type, _id = resolved_global_id.type, resolved_global_id.id object_type = schema.get_type(_type) if not is_node(object_type) or (self.field_object_type and object_type != self.field_object_type): return return object_type.get_node(_id)
def id_fetcher(self, global_id, info): from graphene.relay.utils import is_node schema = info.schema.graphene_schema try: resolved_global_id = from_global_id(global_id) except: return None _type, _id = resolved_global_id.type, resolved_global_id.id object_type = schema.get_type(_type) if not is_node(object_type) or (self.field_object_type and object_type != self.field_object_type): return return object_type.get_node(_id, info)
def id_fetcher(self, global_id, context, info): from graphene.relay.utils import is_node schema = info.schema.graphene_schema try: _type, _id = from_global_id(global_id) except: return None object_type = schema.get_type(_type) if isinstance(self.field_object_type, six.string_types): field_object_type = schema.get_type(self.field_object_type) else: field_object_type = self.field_object_type if not is_node(object_type) or (self.field_object_type and object_type != field_object_type): return return object_type.get_node(_id, context, info)
def _prepare_class(cls): from graphene.relay.utils import is_node if is_node(cls): get_node = getattr(cls, 'get_node') assert get_node, 'get_node classmethod not found in %s Node' % cls assert callable(get_node), 'get_node have to be callable' args = 3 if isinstance(get_node, staticmethod): args -= 1 get_node_num_args = len(inspect.getargspec(get_node).args) if get_node_num_args < args: warnings.warn("get_node will receive also the info arg" " in future versions of graphene".format(cls.__name__), FutureWarning) @staticmethod @wraps(get_node) def wrapped_node(*node_args): if len(node_args) < args: node_args += (None, ) return get_node(*node_args[:-1]) setattr(cls, 'get_node', wrapped_node)
def contribute_to_class(self, cls, name): super(NdbOptions, self).contribute_to_class(cls, name) if is_node(cls): self.exclude_fields = list(self.exclude_fields) + ['id'] self.interfaces.append(Node)
def contribute_to_class(self, cls, name): super(MongoEngineOptions, self).contribute_to_class(cls, name) if is_node(cls): self.exclude_fields = list(self.exclude_fields) + ['id'] self.interfaces.append(Node)
def contribute_to_class(self, cls, name): from graphene.relay.utils import is_node, is_node_type in_node = is_node(cls) or is_node_type(cls) assert in_node, 'GlobalIDField could only be inside a Node, but got %r' % cls super(GlobalIDField, self).contribute_to_class(cls, name)
def for_node(cls, node, edge_type=None): from graphene.relay.utils import is_node edge_type = edge_type or Edge assert is_node(node), 'ObjectTypes in a connection have to be Nodes' return type('%s%s' % (node._meta.type_name, cls._meta.type_name), (cls, ), {'edge_type': edge_type.for_node(node)})
def _prepare_class(cls): from graphene.relay.utils import is_node if is_node(cls): assert hasattr( cls, 'get_node'), 'get_node classmethod not found in %s Node' % cls
def for_node(cls, node): from graphene.relay.utils import is_node assert is_node(node), 'ObjectTypes in a edge have to be Nodes' return type('%s%s' % (node._meta.type_name, cls._meta.type_name), (cls, ), {'node_type': node})
def internal_type(self, schema): from graphene.relay.utils import is_node object_type = self.get_object_type(schema) assert is_node(object_type), 'Only nodes have connections.' return object_type.get_connection(schema)