def test_get_optional_annotation():
# Pair Union
assert get_optional_annotation(Optional[Union[str, bool]]) == Union[str,
bool]
# More than pair Union
assert (get_optional_annotation(Optional[Union[str, int,
bool]]) == Union[str, int,
bool])
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 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