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):
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 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_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 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 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 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)
