strawberry-graphql 0.235.2__py3-none-any.whl → 0.236.1__py3-none-any.whl

strawberry/{custom_scalar.py → types/scalar.py}

@@ -16,9 +16,8 @@ from typing import (
 )
 
 from strawberry.exceptions import InvalidUnionTypeError
-from strawberry.type import StrawberryType
-
-from .utils.str_converters import to_camel_case
+from strawberry.types.base import StrawberryType
+from strawberry.utils.str_converters import to_camel_case
 
 if TYPE_CHECKING:
     from graphql import GraphQLScalarType
@@ -166,30 +165,44 @@ def scalar(
 ) -> Any:
     """Annotates a class or type as a GraphQL custom scalar.
 
+    Args:
+        cls: The class or type to annotate.
+        name: The GraphQL name of the scalar.
+        description: The description of the scalar.
+        specified_by_url: The URL of the specification.
+        serialize: The function to serialize the scalar.
+        parse_value: The function to parse the value.
+        parse_literal: The function to parse the literal.
+        directives: The directives to apply to the scalar.
+
+    Returns:
+        The decorated class or type.
+
     Example usages:
 
-    >>> strawberry.scalar(
-    >>>     datetime.date,
-    >>>     serialize=lambda value: value.isoformat(),
-    >>>     parse_value=datetime.parse_date
-    >>> )
-
-    >>> Base64Encoded = strawberry.scalar(
-    >>>     NewType("Base64Encoded", bytes),
-    >>>     serialize=base64.b64encode,
-    >>>     parse_value=base64.b64decode
-    >>> )
-
-    >>> @strawberry.scalar(
-    >>>     serialize=lambda value: ",".join(value.items),
-    >>>     parse_value=lambda value: CustomList(value.split(","))
-    >>> )
-    >>> class CustomList:
-    >>>     def __init__(self, items):
-    >>>         self.items = items
+    ```python
+    strawberry.scalar(
+        datetime.date,
+        serialize=lambda value: value.isoformat(),
+        parse_value=datetime.parse_date,
+    )
 
-    """
+    Base64Encoded = strawberry.scalar(
+        NewType("Base64Encoded", bytes),
+        serialize=base64.b64encode,
+        parse_value=base64.b64decode,
+    )
 
+
+    @strawberry.scalar(
+        serialize=lambda value: ",".join(value.items),
+        parse_value=lambda value: CustomList(value.split(",")),
+    )
+    class CustomList:
+        def __init__(self, items):
+            self.items = items
+    ```
+    """
     if parse_value is None:
         parse_value = cls
 
@@ -209,3 +222,6 @@ def scalar(
         return wrap
 
     return wrap(cls)
+
+
+__all__ = ["ScalarDefinition", "ScalarWrapper", "scalar"]

strawberry/types/type_resolver.py

@@ -10,16 +10,16 @@ from strawberry.exceptions import (
     FieldWithResolverAndDefaultValueError,
     PrivateStrawberryFieldError,
 )
-from strawberry.field import StrawberryField
-from strawberry.private import is_private
-from strawberry.type import has_object_definition
-from strawberry.unset import UNSET
+from strawberry.types.base import has_object_definition
+from strawberry.types.field import StrawberryField
+from strawberry.types.private import is_private
+from strawberry.types.unset import UNSET
 
 
 def _get_fields(
     cls: Type[Any], original_type_annotations: Dict[str, Type[Any]]
 ) -> List[StrawberryField]:
-    """Get all the strawberry fields off a strawberry.type cls
+    """Get all the strawberry fields off a strawberry.type cls.
 
     This function returns a list of StrawberryFields (one for each field item), while
     also paying attention the name and typing of the field.
@@ -27,16 +27,19 @@ def _get_fields(
     StrawberryFields can be defined on a strawberry.type class as either a dataclass-
     style field or using strawberry.field as a decorator.
 
-    >>> import strawberry
-    >>> @strawberry.type
-    ... class Query:
-    ...     type_1a: int = 5
-    ...     type_1b: int = strawberry.field(...)
-    ...     type_1c: int = strawberry.field(resolver=...)
-    ...
-    ...     @strawberry.field
-    ...     def type_2(self) -> int:
-    ...         ...
+    ```python
+    import strawberry
+
+
+    @strawberry.type
+    class Query:
+        type_1a: int = 5
+        type_1b: int = strawberry.field(...)
+        type_1c: int = strawberry.field(resolver=...)
+
+        @strawberry.field
+        def type_2(self) -> int: ...
+    ```
 
     Type #1:
         A pure dataclass-style field. Will not have a StrawberryField; one will need to
@@ -51,7 +54,6 @@ def _get_fields(
     passing a named function (i.e. not an anonymous lambda) to strawberry.field
     (typically as a decorator).
     """
-
     fields: Dict[str, StrawberryField] = {}
 
     # before trying to find any fields, let's first add the fields defined in
@@ -163,3 +165,6 @@ def _get_fields(
         fields[field_name] = field
 
     return list(fields.values())
+
+
+__all__ = ["_get_fields"]

strawberry/{union.py → types/union.py}

@@ -31,12 +31,12 @@ from strawberry.exceptions import (
     WrongReturnTypeForUnion,
 )
 from strawberry.exceptions.handler import should_use_rich_exceptions
-from strawberry.lazy_type import LazyType
-from strawberry.type import (
+from strawberry.types.base import (
     StrawberryOptional,
     StrawberryType,
     has_object_definition,
 )
+from strawberry.types.lazy_type import LazyType
 
 if TYPE_CHECKING:
     from graphql import (
@@ -173,7 +173,7 @@ class StrawberryUnion(StrawberryType):
         ) -> str:
             assert isinstance(type_, GraphQLUnionType)
 
-            from strawberry.types.types import StrawberryObjectDefinition
+            from strawberry.types.base import StrawberryObjectDefinition
 
             # If the type given is not an Object type, try resolving using `is_type_of`
             # defined on the union's inner types
@@ -250,15 +250,27 @@ def union(
 ) -> StrawberryUnion:
     """Creates a new named Union type.
 
+    Args:
+        name: The GraphQL name of the Union type.
+        types: The types that the Union can be.
+            (Deprecated, use `Annotated[U, strawberry.union("Name")]` instead)
+        description: The  GraphQL description of the Union type.
+        directives: The directives to attach to the Union type.
+
     Example usages:
 
-    >>> @strawberry.type
-    ... class A: ...
-    >>> @strawberry.type
-    ... class B: ...
-    >>> Annotated[A | B, strawberry.union("Name")]
-    """
+    ```python
+    import strawberry
+    from typing import Annotated
+
+    @strawberry.type
+    class A: ...
+
+    @strawberry.type
+    class B: ...
 
+    MyUnion = Annotated[A | B, strawberry.union("Name")]
+    """
     if types is None:
         union = StrawberryUnion(
             name=name,
@@ -299,3 +311,6 @@ def union(
         description=description,
         directives=directives,
     )
+
+
+__all__ = ["StrawberryUnion", "union"]

strawberry/{unset.py → types/unset.py}

@@ -28,6 +28,26 @@ class UnsetType:
 
 
 UNSET: Any = UnsetType()
+"""A special value that can be used to represent an unset value in a field or argument.
+Similar to `undefined` in JavaScript, this value can be used to differentiate between
+a field that was not set and a field that was set to `None` or `null`.
+
+Example:
+
+```python
+import strawberry
+
+
+@strawberry.input
+class UserInput:
+    name: str | None = strawberry.UNSET
+    age: int | None = strawberry.UNSET
+```
+
+In the example above, if `name` or `age` are not provided when creating a `UserInput`
+object, they will be set to `UNSET` instead of `None`. Use `is UNSET` to check
+whether a value is unset.
+"""
 
 
 def _deprecated_is_unset(value: Any) -> bool:

strawberry/utils/aio.py

@@ -67,3 +67,11 @@ async def resolve_awaitable(
 ) -> _R:
     """Resolves an awaitable object and calls a callback with the resolved value."""
     return callback(await awaitable)
+
+
+__all__ = [
+    "aenumerate",
+    "aislice",
+    "asyncgen_to_list",
+    "resolve_awaitable",
+]

strawberry/utils/await_maybe.py

@@ -12,3 +12,6 @@ async def await_maybe(value: AwaitableOrValue[T]) -> T:
         return await value
 
     return cast(T, value)
+
+
+__all__ = ["await_maybe", "AwaitableOrValue", "AsyncIteratorOrIterator"]

strawberry/utils/dataclasses.py

@@ -32,3 +32,6 @@ def add_custom_init_fn(cls: Any) -> None:
             globals_=globals_,
         ),
     )
+
+
+__all__ = ["add_custom_init_fn"]

strawberry/utils/debug.py

@@ -14,8 +14,8 @@ def pretty_print_graphql_operation(
 ) -> None:
     """Pretty print a GraphQL operation using pygments.
 
-    Won't print introspection operation to prevent noise in the output."""
-
+    Won't print introspection operation to prevent noise in the output.
+    """
     try:
         from pygments import highlight, lexers
         from pygments.formatters import Terminal256Formatter
@@ -41,3 +41,6 @@ def pretty_print_graphql_operation(
         print(  # noqa: T201
             highlight(variables_json, lexers.JsonLexer(), Terminal256Formatter())
         )
+
+
+__all__ = ["pretty_print_graphql_operation"]

strawberry/utils/deprecations.py

@@ -25,3 +25,6 @@ class DeprecatedDescriptor:
 
     def inject(self, klass: type) -> None:
         setattr(klass, self.attr_name, self)
+
+
+__all__ = ["DEPRECATION_MESSAGES", "DeprecatedDescriptor"]

strawberry/utils/graphql_lexer.py

@@ -28,3 +28,6 @@ class GraphQLLexer(RegexLexer):
             (r"(\s|,)", token.Text),
         ]
     }
+
+
+__all__ = ["GraphQLLexer"]

strawberry/utils/importer.py

@@ -19,3 +19,6 @@ def import_module_symbol(
         symbol = getattr(symbol, attribute_name)
 
     return symbol
+
+
+__all__ = ["import_module_symbol"]

strawberry/utils/inspect.py

@@ -12,7 +12,6 @@ from typing import (
 )
 from typing_extensions import get_args
 
-from strawberry.type import has_object_definition
 from strawberry.utils.typing import is_generic_alias
 
 
@@ -29,8 +28,7 @@ def in_async_context() -> bool:
 
 @lru_cache(maxsize=250)
 def get_func_args(func: Callable[[Any], Any]) -> List[str]:
-    """Returns a list of arguments for the function"""
-
+    """Returns a list of arguments for the function."""
     sig = inspect.signature(func)
 
     return [
@@ -45,38 +43,46 @@ def get_specialized_type_var_map(cls: type) -> Optional[Dict[str, type]]:
 
     Consider the following:
 
-        >>> class Foo(Generic[T]):
-        ...     ...
-        ...
-        >>> class Bar(Generic[K]):
-        ...     ...
-        ...
-        >>> class IntBar(Bar[int]):
-        ...     ...
-        ...
-        >>> class IntBarSubclass(IntBar):
-        ...     ...
-        ...
-        >>> class IntBarFoo(IntBar, Foo[str]):
-        ...     ...
-        ...
+    ```python
+    class Foo(Generic[T]): ...
+
+
+    class Bar(Generic[K]): ...
+
+
+    class IntBar(Bar[int]): ...
+
+
+    class IntBarSubclass(IntBar): ...
+
+
+    class IntBarFoo(IntBar, Foo[str]): ...
+    ```
 
     This would return:
 
-        >>> get_specialized_type_var_map(object)
-        None
-        >>> get_specialized_type_var_map(Foo)
-        {}
-        >>> get_specialized_type_var_map(Bar)
-        {~T: ~T}
-        >>> get_specialized_type_var_map(IntBar)
-        {~T: int}
-        >>> get_specialized_type_var_map(IntBarSubclass)
-        {~T: int}
-        >>> get_specialized_type_var_map(IntBarFoo)
-        {~T: int, ~K: str}
+    ```python
+    get_specialized_type_var_map(object)
+    # None
+
+    get_specialized_type_var_map(Foo)
+    # {}
+
+    get_specialized_type_var_map(Bar)
+    # {~T: ~T}
+
+    get_specialized_type_var_map(IntBar)
+    # {~T: int}
 
+    get_specialized_type_var_map(IntBarSubclass)
+    # {~T: int}
+
+    get_specialized_type_var_map(IntBarFoo)
+    # {~T: int, ~K: str}
+    ```
     """
+    from strawberry.types.base import has_object_definition
+
     orig_bases = getattr(cls, "__orig_bases__", None)
     if orig_bases is None:
         # Specialized generic aliases will not have __orig_bases__
@@ -114,3 +120,6 @@ def get_specialized_type_var_map(cls: type) -> Optional[Dict[str, type]]:
         )
 
     return type_var_map
+
+
+__all__ = ["in_async_context", "get_func_args", "get_specialized_type_var_map"]

strawberry/utils/logging.py

@@ -23,3 +23,6 @@ class StrawberryLogger:
         **logger_kwargs: Any,
     ) -> None:
         cls.logger.error(error, exc_info=error.original_error, **logger_kwargs)
+
+
+__all__ = ["StrawberryLogger"]

strawberry/utils/operation.py

@@ -38,3 +38,6 @@ def get_operation_type(
         raise RuntimeError("Can't get GraphQL operation type")
 
     return OperationType(definition.operation.value)
+
+
+__all__ = ["get_first_operation", "get_operation_type"]

strawberry/utils/str_converters.py

@@ -24,3 +24,6 @@ def capitalize_first(name: str) -> str:
 def to_snake_case(name: str) -> str:
     name = re.sub("(.)([A-Z][a-z]+)", r"\1_\2", name)
     return re.sub("([a-z0-9])([A-Z])", r"\1_\2", name).lower()
+
+
+__all__ = ["to_camel_case", "to_kebab_case", "capitalize_first", "to_snake_case"]

strawberry/utils/typing.py

@@ -44,10 +44,13 @@ def get_generic_alias(type_: Type) -> Type:
     Given a type, its generic alias from `typing` module will be returned
     if it exists. For example:
 
-        >>> get_generic_alias(list)
-        typing.List
-        >>> get_generic_alias(dict)
-        typing.Dict
+    ```python
+    get_generic_alias(list)
+    # typing.List
+
+    get_generic_alias(dict)
+    # typing.Dict
+    ```
 
     This is mostly useful for python versions prior to 3.9, to get a version
     of a concrete type which supports `__class_getitem__`. In 3.9+ types like
@@ -78,16 +81,14 @@ def is_generic_alias(type_: Any) -> TypeGuard[_GenericAlias]:
 
 
 def is_list(annotation: object) -> bool:
-    """Returns True if annotation is a List"""
-
+    """Returns True if annotation is a List."""
     annotation_origin = getattr(annotation, "__origin__", None)
 
     return annotation_origin == list
 
 
 def is_union(annotation: object) -> bool:
-    """Returns True if annotation is a Union"""
-
+    """Returns True if annotation is a Union."""
     # this check is needed because unions declared with the new syntax `A | B`
     # don't have a `__origin__` property on them, but they are instances of
     # `UnionType`, which is only available in Python 3.10+
@@ -105,8 +106,7 @@ def is_union(annotation: object) -> bool:
 
 
 def is_optional(annotation: Type) -> bool:
-    """Returns True if the annotation is Optional[SomeType]"""
-
+    """Returns True if the annotation is Optional[SomeType]."""
     # Optionals are represented as unions
 
     if not is_union(annotation):
@@ -153,7 +153,6 @@ def is_generic_subclass(annotation: type) -> bool:
 
 def is_generic(annotation: type) -> bool:
     """Returns True if the annotation is or extends a generic."""
-
     return (
         # TODO: These two lines appear to have the same effect. When will an
         #       annotation have parameters but not satisfy the first condition?
@@ -164,7 +163,6 @@ def is_generic(annotation: type) -> bool:
 
 def is_type_var(annotation: Type) -> bool:
     """Returns True if the annotation is a TypeVar."""
-
     return isinstance(annotation, TypeVar)
 
 
@@ -259,7 +257,7 @@ def _get_namespace_from_ast(
     globalns: Optional[Dict] = None,
     localns: Optional[Dict] = None,
 ) -> Dict[str, Type]:
-    from strawberry.lazy_type import StrawberryLazyReference
+    from strawberry.types.lazy_type import StrawberryLazyReference
 
     extra = {}
 
@@ -328,9 +326,9 @@ def eval_type(
     localns: Optional[Dict] = None,
 ) -> Type:
     """Evaluates a type, resolving forward references."""
-    from strawberry.auto import StrawberryAuto
-    from strawberry.lazy_type import StrawberryLazyReference
-    from strawberry.private import StrawberryPrivate
+    from strawberry.types.auto import StrawberryAuto
+    from strawberry.types.lazy_type import StrawberryLazyReference
+    from strawberry.types.private import StrawberryPrivate
 
     globalns = globalns or {}
     # If this is not a string, maybe its args are (e.g. List["Foo"])
@@ -411,3 +409,22 @@ def eval_type(
         )
 
     return type_
+
+
+__all__ = [
+    "get_generic_alias",
+    "is_generic_alias",
+    "is_list",
+    "is_union",
+    "is_optional",
+    "get_optional_annotation",
+    "get_list_annotation",
+    "is_concrete_generic",
+    "is_generic_subclass",
+    "is_generic",
+    "is_type_var",
+    "is_classvar",
+    "type_has_annotation",
+    "get_parameters",
+    "eval_type",
+]

{strawberry_graphql-0.235.2.dist-info → strawberry_graphql-0.236.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: strawberry-graphql
-Version: 0.235.2
+Version: 0.236.1
 Summary: A library for creating GraphQL APIs
 Home-page: https://strawberry.rocks/
 License: MIT