def print_type(gtype, nonnull=True, except_types=()): if isinstance(gtype, except_types): raise ValidationError(f'{gtype} is not a valid type') literal = None if is_union(gtype): if is_optional(gtype): return f'{print_type(gtype.__args__[0], nonnull=False, except_types=except_types)}' # noqa else: raise ValidationError( f'Native Union type is not supported except Optional') elif is_list(gtype): literal = f'[{print_type(gtype.__args__[0], except_types=except_types)}]' # noqa elif isinstance(gtype, types.ObjectType): literal = f'{gtype.__name__}' elif gtype in VALID_BASIC_TYPES: literal = VALID_BASIC_TYPES[gtype] elif gtype is None or gtype == type(None): # noqa return 'null' elif isinstance(gtype, types.UnionType): literal = f'{gtype.__name__}' elif isinstance(gtype, types.EnumType): literal = f'{gtype.__name__}' elif isinstance(gtype, types.InputType): literal = f'{gtype.__name__}' elif isinstance(gtype, types.InterfaceType): literal = f'{gtype.__name__}' else: raise ValidationError(f'Can not convert type {gtype} to GraphQL type') if nonnull: literal += '!' return literal
def register_types(cls, types): for ptype in types: if ptype in cls.validated_type: continue cls.validated_type.append(ptype) if isinstance(ptype, ObjectType): cls.registered_type.append(ptype) cls.register_fields_type(ptype.__fields__.values()) elif is_union(ptype) or is_list(ptype): cls.register_types(ptype.__args__) elif isinstance(ptype, UnionType): cls.registered_type.append(ptype) cls.register_types(ptype.members) elif isinstance(ptype, InputType): cls.registered_type.append(ptype) cls.register_fields_type(ptype.__fields__.values()) elif isinstance(ptype, InterfaceType): cls.registered_type.append(ptype) cls.register_fields_type(ptype.__fields__.values()) cls.register_types(ptype.__subclasses__()) elif isinstance(ptype, EnumType): cls.registered_type.append(ptype) else: # Other basic types, do not need be handled pass
def replace_forwarded_type(self, ptype): if hasattr(ptype, '__args__'): args = [self.replace_forwarded_type(t) for t in ptype.__args__] if is_union(ptype): return PyUnion[tuple(args)] elif is_list(ptype): return List[tuple(args)] elif isinstance(ptype, (str, ForwardRef)): return self.get_type(ptype) return ptype
def load_variable(variable, ptype): if isinstance(ptype, types.InputType): data = {} keys = ptype.__dataclass_fields__.keys() for key, value in variable.items(): snake_cases = to_snake_case(key) data[snake_cases if key not in keys else key] = load_variable( value, ptype.__fields__[snake_cases].ftype) return ptype(**data) elif is_list(ptype): return [load_variable(i, ptype.__args__[0]) for i in variable] elif is_optional(ptype): if variable is None: return None return load_variable(variable, ptype.__args__[0]) elif isinstance(ptype, types.EnumType): return getattr(ptype, variable) else: return variable
def __check_return_type__(cls, return_type, result): if is_optional(return_type): if result is None: return True return cls.__check_return_type__(return_type.__args__[0], result) elif is_list(return_type): if len(result) == 0: return True for item in result: if not cls.__check_return_type__(return_type.__args__[0], item): return False return True elif isinstance(return_type, types.UnionType): for member in return_type.members: if cls.__check_return_type__(member, result): return True elif isinstance(result, return_type): return True return False
def test_is_list(): assert is_list(typing.List[str]) is True assert is_list(typing.Union[str, int, None]) is False