def _get_type_mapping_from_actual_type( root) -> typing.Dict[typing.Any, typing.Type]: # we map ~T to the actual type of root type_var_to_actual_type = {} for field_name, annotation in root.__annotations__.items(): # when we have a list we want to get the type of the elements contained in the # list, to do so we currently only get the first time (if the list is not empty) # this might break in more complex cases, but should suffice for now. if is_list(annotation): annotation = get_list_annotation(annotation) if is_type_var(annotation): values = getattr(root, field_name) if values: type_var_to_actual_type[annotation] = type(values[0]) elif is_type_var(annotation): type_var_to_actual_type[annotation] = type( getattr(root, field_name)) elif is_generic(annotation): type_var_to_actual_type.update( _get_type_mapping_from_actual_type(getattr(root, field_name))) return type_var_to_actual_type
def normalize_type(type_) -> Any: if is_list(type_): return List[normalize_type(get_list_annotation(type_))] # type: ignore if is_optional(type_): return get_optional_annotation(type_) return type_
def field_type_to_type(type_): error_class: Any = str strawberry_type: Any = error_class if is_list(type_): child_type = get_list_annotation(type_) if is_list(child_type): strawberry_type = field_type_to_type(child_type) elif issubclass(child_type, BaseModel): strawberry_type = get_strawberry_type_from_model(child_type) else: strawberry_type = List[error_class] strawberry_type = Optional[strawberry_type] elif issubclass(type_, BaseModel): strawberry_type = get_strawberry_type_from_model(type_) return Optional[strawberry_type] return Optional[List[strawberry_type]]
def resolve_type( field_definition: Union[FieldDefinition, ArgumentDefinition]) -> None: # convert a python type to include a strawberry definition, so for example # Union becomes a class with a UnionDefinition, Generics become an actual # type definition. This helps with making the code to convert the type definitions # to GraphQL types, as we only have to deal with Python's typings in one place. type = cast(Type, field_definition.type) origin_name = cast(str, field_definition.origin_name) if isinstance(type, LazyType): field_definition.type = type.resolve_type() if isinstance(type, str): module = sys.modules[field_definition.origin.__module__].__dict__ type = eval(type, module) field_definition.type = type if is_forward_ref(type): # if the type is a forward reference we try to resolve the type by # finding it in the global namespace of the module where the field # was initially declared. This will break when the type is not declared # in the main scope, but we don't want to support that use case # see https://mail.python.org/archives/list/[email protected]/thread/SNKJB2U5S74TWGDWVD6FMXOP63WVIGDR/ # noqa: E501 type_name = type.__forward_arg__ module = sys.modules[field_definition.origin.__module__] # TODO: we should probably raise an error if we can't find the type type = module.__dict__[type_name] field_definition.type = type return if is_async_generator(type): # TODO: shall we raise a warning if field is not used in a subscription? # async generators are used in subscription, we only need the yield type # https://docs.python.org/3/library/typing.html#typing.AsyncGenerator field_definition.type = get_async_generator_annotation(type) return resolve_type(field_definition) # check for Optional[A] which is represented as Union[A, None], we # have an additional check for proper unions below if is_optional(type) and len(type.__args__) == 2: # this logics works around List of optionals and Optional lists of Optionals: # >>> Optional[List[Str]] # >>> Optional[List[Optional[Str]]] # the field is only optional if it is not a list or if it was already optional # since we mark the child as optional when the field is a list field_definition.is_optional = (True and not field_definition.is_list or field_definition.is_optional) field_definition.is_child_optional = field_definition.is_list field_definition.type = get_optional_annotation(type) return resolve_type(field_definition) elif is_list(type): # TODO: maybe this should be an argument definition when it is argument # but doesn't matter much child_definition = FieldDefinition( origin=field_definition.origin, # type: ignore name=None, origin_name=None, type=get_list_annotation(type), ) resolve_type(child_definition) field_definition.type = None field_definition.is_list = True field_definition.child = child_definition return # case for Union[A, B, C], it also handles Optional[Union[A, B, C]] as optionals # type hints are represented as Union[..., None]. elif is_union(type): # Optional[Union[A, B]] is represented as Union[A, B, None] so we need # too check again if the field is optional as the check above only checks # for single Optionals field_definition.is_optional = is_optional(type) types = type.__args__ # we use a simplified version of resolve_type since unions in GraphQL # are simpler and cannot contain lists or optionals types = tuple( _resolve_generic_type(t, origin_name) for t in types if t is not None.__class__) field_definition.is_union = True field_definition.type = union(get_name_from_types(types), types) # case for Type[A], we want to convert generics to have the concrete types # when we pass them, so that we don't have to deal with generics when # generating the GraphQL types later on. elif hasattr(type, "_type_definition") and type._type_definition.is_generic: args = get_args(type) # raise an error when using generics without passing any type parameter, ie: # >>> class X(Generic[T]): ... # >>> a: X # instead of # >>> a: X[str] if len(args) == 0: name = cast(str, field_definition.origin_name) raise MissingTypesForGenericError(name, type) # we only make a copy when all the arguments are not type vars if not all(is_type_var(a) for a in args): field_definition.type = copy_type_with(type, *args) if isinstance(type, StrawberryUnion): field_definition.is_union = True