def _convert_primitive_type(self, type, **kwargs): """ A helper for converting primitive types to Graphene. """ if in_kwargs_and_true(kwargs, "input"): return type if in_kwargs_and_true(kwargs, "input_field"): return get_field_as(type, _as=graphene.InputField) return get_field_as(type, _as=graphene.Field)
def _generate_default_filters( cls, model, field_filters: 'Dict[str, Union[Iterable[str], Any]]') -> dict: """ Generate GraphQL fields from SQLAlchemy model columns. Args: model: SQLAlchemy model. field_filters: Filters for fields. Returns: GraphQL fields dictionary: field name (key) - field instance (value). """ graphql_filters = {} filters_map = cls.ALLOWED_FILTERS model_fields = { c.name: { 'column': c, 'type': c.type, 'nullable': c.nullable } for c in model.__table__.columns if c.name in field_filters } for field_name, field_object in model_fields.items(): column_type = field_object['type'] expressions = field_filters[field_name] if expressions == cls.ALL: type_class = column_type.__class__ try: expressions = filters_map[type_class].copy() except KeyError: for type_, exprs in filters_map.items(): if issubclass(type_class, type_): expressions = exprs.copy() break else: raise KeyError('Unsupported column type. ' 'Hint: use EXTRA_ALLOWED_FILTERS.') if field_object['nullable']: expressions.append(cls.IS_NULL) field_type = convert_sqlalchemy_type(column_type, field_object['column']) fields = cls._generate_filter_fields(expressions, field_name, field_type, field_object['nullable']) for name, field in fields.items(): graphql_filters[name] = get_field_as(field, graphene.InputField) return graphql_filters
def extend(cls, fname, ftype, fresolver): if fname in cls._meta.fields: raise ValueError('Resolver for field {}.{} already exists!'.format( cls.__name__, fname)) field = {fname: get_field_as(ftype, graphene.Field)} cls._meta.local_fields.update(field) cls._meta.fields.update(field) setattr(cls, 'resolve_' + fname, fresolver)
def _generate_default_filters( cls, model, field_filters: 'Dict[str, Union[Iterable[str], Any]]') -> dict: """ Generate GraphQL fields from SQLAlchemy model columns. Args: model: SQLAlchemy model. field_filters: Filters for fields. Returns: GraphQL fields dictionary: field name (key) - field instance (value). """ graphql_filters = {} filters_map = cls.ALLOWED_FILTERS model_fields = { c.name: { 'column': c, 'type': c.type, 'nullable': c.nullable } for c in model.__table__.columns if c.name in field_filters } for field_name, field_object in model_fields.items(): column_type = field_object['type'] expressions = field_filters[field_name] if expressions == cls.ALL: expressions = filters_map[column_type.__class__].copy() if field_object['nullable']: expressions.append(cls.IS_NULL) field_type = convert_sqlalchemy_type(column_type, field_object['column']) fields = cls._generate_filter_fields(expressions, field_name, field_type, field_object['nullable']) for name, field in fields.items(): graphql_filters[name] = get_field_as(field, graphene.InputField) return graphql_filters
def __new__(cls, name, bases, attrs): if not is_base_type(bases, SerializerMutationMeta): return type.__new__(cls, name, bases, attrs) options = Options( attrs.pop('Meta', None), name=name, description=attrs.pop('__doc__', None), serializer_class=None, local_fields=None, only_fields=(), exclude_fields=(), interfaces=(), registry=None ) if not options.serializer_class: raise Exception('Missing serializer_class') cls = ObjectTypeMeta.__new__( cls, name, bases, dict(attrs, _meta=options) ) serializer_fields = cls.fields_for_serializer(options) options.serializer_fields = yank_fields_from_attrs( serializer_fields, _as=Field, ) options.fields = merge( options.interface_fields, options.serializer_fields, options.base_fields, options.local_fields, {'errors': get_field_as(cls.errors, Field)} ) cls.Input = convert_serializer_to_input_type(options.serializer_class) cls.Field = partial( Field, cls, resolver=cls.mutate, input=Argument(cls.Input, required=True) ) return cls
def get_base_fields(bases, _as=None): ''' Get all the fields in the given bases same as graphene.types.utils.get_base_fields but with SQLAlchemyInterface check ''' fields = OrderedDict() from graphene.types import AbstractType, Interface from .schema import SQLAlchemyInterface # We allow inheritance in AbstractTypes and Interfaces but not ObjectTypes inherited_bases = (AbstractType, Interface, SQLAlchemyInterface) for base in bases: if base in inherited_bases or not issubclass(base, inherited_bases): continue for name, field in base._meta.fields.items(): if name in fields: continue fields[name] = get_field_as(field, _as=_as) return fields
def get_base_fields(bases, _as=None): ''' Get all the fields in the given bases same as graphene.types.utils.get_base_fields but with SQLAlchemyInterface check ''' fields = OrderedDict() from graphene.types import AbstractType from .types import SQLAlchemyInterface # We allow inheritance in AbstractTypes and Interfaces but not ObjectTypes inherited_bases = (AbstractType, Interface, SQLAlchemyInterface) for base in bases: if base in inherited_bases or not issubclass(base, inherited_bases): continue for name, field in base._meta.fields.items(): if name in fields: continue fields[name] = get_field_as(field, _as=_as) return fields
def __new__(cls, name, bases, attrs): if not is_base_type(bases, SerializerMutationMeta): return type.__new__(cls, name, bases, attrs) options = Options(attrs.pop('Meta', None), name=name, description=attrs.pop('__doc__', None), serializer_class=None, local_fields=None, only_fields=(), exclude_fields=(), interfaces=(), registry=None) if not options.serializer_class: raise Exception('Missing serializer_class') cls = ObjectTypeMeta.__new__(cls, name, bases, dict(attrs, _meta=options)) serializer_fields = cls.fields_for_serializer(options) options.serializer_fields = yank_fields_from_attrs( serializer_fields, _as=Field, ) options.fields = merge(options.interface_fields, options.serializer_fields, options.base_fields, options.local_fields, {'errors': get_field_as(cls.errors, Field)}) cls.Input = convert_serializer_to_input_type(options.serializer_class) cls.Field = partial(Field, cls, resolver=cls.mutate, input=Argument(cls.Input, required=True)) return cls
def composite_type(self, type, **kwargs): attrs = {} for name, return_type in type.field_map.items(): attrs[name] = get_instantiated_type(return_type).convert( self, input=in_kwargs_and_true(kwargs, "input"), input_field=in_kwargs_and_true(kwargs, "input_field")) if in_kwargs_and_true(kwargs, "input") or in_kwargs_and_true( kwargs, "input_field"): input_class = create_class( "{}Input".format(type.type_name), (graphene.InputObjectType, ), attrs, )(required=type.kwargs["required"]) if in_kwargs_and_true(kwargs, "input"): return input_class return get_field_as(input_class, _as=graphene.InputField) type_class = create_class("{}ObjectType".format(type.type_name), (graphene.ObjectType, ), attrs) return graphene.Field(type_class)