strawberry-graphql 0.235.1.dev1719337273__py3-none-any.whl → 0.236.0__py3-none-any.whl

strawberry/relay/types.py

@@ -26,14 +26,17 @@ from typing import (
 )
 from typing_extensions import Annotated, Literal, Self, TypeAlias, get_args, get_origin
 
-from strawberry.field import field
-from strawberry.lazy_type import LazyType
-from strawberry.object_type import interface, type
-from strawberry.private import StrawberryPrivate
 from strawberry.relay.exceptions import NodeIDAnnotationError
-from strawberry.type import StrawberryContainer, get_object_definition
+from strawberry.types.base import (
+    StrawberryContainer,
+    StrawberryObjectDefinition,
+    get_object_definition,
+)
+from strawberry.types.field import field
 from strawberry.types.info import Info  # noqa: TCH001
-from strawberry.types.types import StrawberryObjectDefinition
+from strawberry.types.lazy_type import LazyType
+from strawberry.types.object_type import interface, type
+from strawberry.types.private import StrawberryPrivate
 from strawberry.utils.aio import aenumerate, aislice, resolve_awaitable
 from strawberry.utils.inspect import in_async_context
 from strawberry.utils.typing import eval_type, is_classvar
@@ -319,9 +322,14 @@ class NodeIDPrivate(StrawberryPrivate):
     The `Node` interface will automatically create and resolve GlobalIDs
     based on the field annotated with `NodeID`. e.g:
 
-      >>> @strawberry.type
-      ... class Fruit(Node):
-      ...     code: NodeID[str]
+    ```python
+    import strawberry
+
+
+    @strawberry.type
+    class Fruit(Node):
+        code: NodeID[str]
+    ```
 
     In this case, `code` will be used to generate a global ID in the
     format `Fruit:<code>` and will be exposed as `id: GlobalID!` in the
@@ -352,17 +360,20 @@ class Node:
             single node id.
 
     Example:
+    ```python
+    import strawberry
+
 
-        >>> @strawberry.type
-        ... class Fruit(Node):
-        ...     id: NodeID[int]
-        ...     name: str
-        ...
-        ... @classmethod
-        ... def resolve_nodes(cls, *, info, node_ids, required=False):
-        ...     # Return an iterable of fruits in here
-        ...     ...
+    @strawberry.type
+    class Fruit(strawberry.relay.Node):
+        id: strawberry.relay.NodeID[int]
+        name: str
 
+        @classmethod
+        def resolve_nodes(cls, *, info, node_ids, required=False):
+            # Return an iterable of fruits in here
+            ...
+    ```
     """
 
     _id_attr: ClassVar[Optional[str]] = None
@@ -467,10 +478,8 @@ class Node:
         You can override this method to provide a custom implementation.
 
         Args:
-            info:
-                The strawberry execution info resolve the type name from
-            root:
-                The node to resolve
+            info: The strawberry execution info resolve the type name from.
+            root: The node to resolve.
 
         Returns:
             The resolved id (which is expected to be str)
@@ -535,12 +544,9 @@ class Node:
         returned as `None`.
 
         Args:
-            info:
-                The strawberry execution info resolve the type name from
-            node_ids:
-                List of node ids that should be returned
-            required:
-                If `True`, all `node_ids` requested must exist. If they don't,
+            info: The strawberry execution info resolve the type name from.
+            node_ids: List of node ids that should be returned.
+            required: If `True`, all `node_ids` requested must exist. If they don't,
                 an error must be raised. If `False`, missing nodes should be
                 returned as `None`. It only makes sense when passing a list of
                 `node_ids`, otherwise it will should ignored.
@@ -595,18 +601,14 @@ class Node:
         a single node id.
 
         Args:
-            info:
-                The strawberry execution info resolve the type name from
-            node_id:
-                The id of the node to be retrieved
-            required:
-                if the node is required or not to exist. If not, then None
+            info: The strawberry execution info resolve the type name from.
+            node_id: The id of the node to be retrieved.
+            required: if the node is required or not to exist. If not, then None
                 should be returned if it doesn't exist. Otherwise an exception
                 should be raised.
 
         Returns:
             The resolved node or None if it was not found
-
         """
         retval = cls.resolve_nodes(info=info, node_ids=[node_id], required=required)
 
@@ -629,7 +631,6 @@ class PageInfo:
             When paginating backwards, the cursor to continue
         end_cursor:
             When paginating forwards, the cursor to continue
-
     """
 
     has_next_page: bool = field(
@@ -655,15 +656,10 @@ class Edge(Generic[NodeType]):
             A cursor for use in pagination
         node:
             The item at the end of the edge
-
     """
 
-    cursor: str = field(
-        description="A cursor for use in pagination",
-    )
-    node: NodeType = field(
-        description="The item at the end of the edge",
-    )
+    cursor: str = field(description="A cursor for use in pagination")
+    node: NodeType = field(description="The item at the end of the edge")
 
     @classmethod
     def resolve_edge(cls, node: NodeType, *, cursor: Any = None) -> Self:
@@ -682,11 +678,9 @@ class Connection(Generic[NodeType]):
 
     """
 
-    page_info: PageInfo = field(
-        description="Pagination data for this connection",
-    )
+    page_info: PageInfo = field(description="Pagination data for this connection")
     edges: List[Edge[NodeType]] = field(
-        description="Contains the nodes in this connection",
+        description="Contains the nodes in this connection"
     )
 
     @classmethod
@@ -702,9 +696,11 @@ class Connection(Generic[NodeType]):
         Args:
             node:
                 The resolved node which should return an instance of this
-                connection's `NodeType`
+                connection's `NodeType`.
             info:
-                The strawberry execution info resolve the type name from
+                The strawberry execution info resolve the type name from.
+            **kwargs:
+                Additional arguments passed to the resolver.
 
         """
         return node
@@ -727,18 +723,13 @@ class Connection(Generic[NodeType]):
         on `first`/`last`/`before`/`after` arguments.
 
         Args:
-            info:
-                The strawberry execution info resolve the type name from
-            nodes:
-                An iterable/iteretor of nodes to paginate
-            before:
-                Returns the items in the list that come before the specified cursor
-            after:
-                Returns the items in the list that come after the specified cursor
-            first:
-                Returns the first n items from the list
-            last:
-                Returns the items in the list that come after the specified cursor
+            info: The strawberry execution info resolve the type name from.
+            nodes: An iterable/iteretor of nodes to paginate.
+            before: Returns the items in the list that come before the specified cursor.
+            after: Returns the items in the list that come after the specified cursor.
+            first: Returns the first n items from the list.
+            last: Returns the items in the list that come after the specified cursor.
+            kwargs: Additional arguments passed to the resolver.
 
         Returns:
             The resolved `Connection`
@@ -759,11 +750,9 @@ class ListConnection(Connection[NodeType]):
 
     """
 
-    page_info: PageInfo = field(
-        description="Pagination data for this connection",
-    )
+    page_info: PageInfo = field(description="Pagination data for this connection")
     edges: List[Edge[NodeType]] = field(
-        description="Contains the nodes in this connection",
+        description="Contains the nodes in this connection"
     )
 
     @classmethod
@@ -783,25 +772,19 @@ class ListConnection(Connection[NodeType]):
         This uses the described Relay Pagination algorithm_
 
         Args:
-            info:
-                The strawberry execution info resolve the type name from
-            nodes:
-                An iterable/iteretor of nodes to paginate
-            before:
-                Returns the items in the list that come before the specified cursor
-            after:
-                Returns the items in the list that come after the specified cursor
-            first:
-                Returns the first n items from the list
-            last:
-                Returns the items in the list that come after the specified cursor
+            info: The strawberry execution info resolve the type name from.
+            nodes: An iterable/iteretor of nodes to paginate.
+            before: Returns the items in the list that come before the specified cursor.
+            after: Returns the items in the list that come after the specified cursor.
+            first: Returns the first n items from the list.
+            last: Returns the items in the list that come after the specified cursor.
+            kwargs: Additional arguments passed to the resolver.
 
         Returns:
             The resolved `Connection`
 
         .. _Relay Pagination algorithm:
             https://relay.dev/graphql/connections.htm#sec-Pagination-algorithm
-
         """
         slice_metadata = SliceMetadata.from_arguments(
             info,
@@ -949,3 +932,20 @@ class ListConnection(Connection[NodeType]):
                 has_next_page=has_next_page,
             ),
         )
+
+
+__all__ = [
+    "GlobalID",
+    "GlobalIDValueError",
+    "Node",
+    "NodeID",
+    "NodeIDAnnotationError",
+    "NodeIDPrivate",
+    "NodeIterableType",
+    "NodeType",
+    "PREFIX",
+    "Connection",
+    "Edge",
+    "PageInfo",
+    "ListConnection",
+]

strawberry/relay/utils.py

@@ -6,8 +6,8 @@ import sys
 from typing import TYPE_CHECKING, Any, Tuple, Union
 from typing_extensions import Self, assert_never
 
+from strawberry.types.base import StrawberryObjectDefinition
 from strawberry.types.nodes import InlineFragment, Selection
-from strawberry.types.types import StrawberryObjectDefinition
 
 if TYPE_CHECKING:
     from strawberry.types.info import Info
@@ -86,6 +86,7 @@ def should_resolve_list_connection_edges(info: Info) -> bool:
 
     def _check_selection(selection: Selection) -> bool:
         """Recursively inspect the selection to check if the user requested to resolve the `edges` field.
+
         Args:
             selection (Selection): The selection to check.
 
@@ -187,3 +188,11 @@ class SliceMetadata:
             end=end,
             expected=expected,
         )
+
+
+__all__ = [
+    "from_base64",
+    "to_base64",
+    "should_resolve_list_connection_edges",
+    "SliceMetadata",
+]

strawberry/resolvers.py

@@ -4,3 +4,6 @@ from typing import Any, Callable
 def is_default_resolver(func: Callable[..., Any]) -> bool:
     """Check whether the function is a default resolver or a user provided one."""
     return getattr(func, "_is_default", False)
+
+
+__all__ = ["is_default_resolver"]

strawberry/sanic/context.py

@@ -22,3 +22,6 @@ class StrawberrySanicContext(TypedDict):
         )
 
         return super().__getitem__(key)
+
+
+__all__ = ["StrawberrySanicContext"]

strawberry/sanic/utils.py

@@ -10,18 +10,17 @@ if TYPE_CHECKING:
 
 
 def convert_request_to_files_dict(request: Request) -> Dict[str, Any]:
-    """
-    request.files has the following format, even if only a single file is uploaded:
+    """Converts the request.files dictionary to a dictionary of BytesIO objects.
+
+    `request.files` has the following format, even if only a single file is uploaded:
 
+    ```python
     {
-        'textFile': [
-            sanic.request.File(
-                type='text/plain',
-                body=b'strawberry',
-                name='textFile.txt'
-            )
+        "textFile": [
+            sanic.request.File(type="text/plain", body=b"strawberry", name="textFile.txt")
         ]
     }
+    ```
 
     Note that the dictionary entries are lists.
     """
@@ -38,3 +37,6 @@ def convert_request_to_files_dict(request: Request) -> Dict[str, Any]:
         files_dict[field_name] = BytesIO(file_list[0].body)
 
     return files_dict
+
+
+__all__ = ["convert_request_to_files_dict"]

strawberry/sanic/views.py

@@ -6,7 +6,6 @@ from typing import (
     TYPE_CHECKING,
     Any,
     Dict,
-    List,
     Mapping,
     Optional,
     Type,
@@ -43,12 +42,7 @@ class SanicHTTPRequestAdapter(AsyncHTTPRequestAdapter):
         # the keys are the unique variable names and the values are lists
         # of values for each variable name. To ensure consistency, we're
         # enforcing the use of the first value in each list.
-
-        args = cast(
-            Dict[str, Optional[List[str]]],
-            self.request.get_args(keep_blank_values=True),
-        )
-
+        args = self.request.get_args(keep_blank_values=True)
         return {k: args.get(k, None) for k in args}
 
     @property
@@ -78,8 +72,7 @@ class GraphQLView(
     AsyncBaseHTTPView[Request, HTTPResponse, TemporalResponse, Context, RootValue],
     HTTPMethodView,
 ):
-    """
-    Class based view to handle GraphQL HTTP Requests
+    """Class based view to handle GraphQL HTTP Requests.
 
     Args:
         schema: strawberry.Schema
@@ -178,3 +171,6 @@ class GraphQLView(
             return await self.run(request)
         except HTTPException as e:
             return HTTPResponse(e.reason, status=e.status_code)
+
+
+__all__ = ["GraphQLView"]

strawberry/scalars.py

@@ -3,13 +3,14 @@ from __future__ import annotations
 import base64
 from typing import TYPE_CHECKING, Any, Dict, NewType, Union
 
-from .custom_scalar import scalar
+from strawberry.types.scalar import scalar
 
 if TYPE_CHECKING:
-    from .custom_scalar import ScalarDefinition, ScalarWrapper
+    from strawberry.types.scalar import ScalarDefinition, ScalarWrapper
 
 
 ID = NewType("ID", str)
+"""Represent the GraphQL `ID` scalar type."""
 
 JSON = scalar(
     NewType("JSON", object),  # mypy doesn't like `NewType("name", Any)`
@@ -62,3 +63,6 @@ def is_scalar(
         return True
 
     return hasattr(annotation, "_scalar_definition")
+
+
+__all__ = ["ID", "JSON", "Base16", "Base32", "Base64", "is_scalar"]

strawberry/schema/base.py

@@ -10,14 +10,14 @@ from strawberry.utils.logging import StrawberryLogger
 if TYPE_CHECKING:
     from graphql import GraphQLError
 
-    from strawberry.custom_scalar import ScalarDefinition
     from strawberry.directive import StrawberryDirective
-    from strawberry.enum import EnumDefinition
     from strawberry.schema.schema_converter import GraphQLCoreConverter
     from strawberry.types import ExecutionContext, ExecutionResult
+    from strawberry.types.base import StrawberryObjectDefinition
+    from strawberry.types.enum import EnumDefinition
     from strawberry.types.graphql import OperationType
-    from strawberry.types.types import StrawberryObjectDefinition
-    from strawberry.union import StrawberryUnion
+    from strawberry.types.scalar import ScalarDefinition
+    from strawberry.types.union import StrawberryUnion
 
     from .config import StrawberryConfig
 
@@ -113,3 +113,6 @@ class BaseSchema(Protocol):
     ) -> None:
         for error in errors:
             StrawberryLogger.error(error, execution_context)
+
+
+__all__ = ["BaseSchema"]

strawberry/schema/compat.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 from typing import TYPE_CHECKING, Dict, Union
 
 from strawberry.scalars import is_scalar as is_strawberry_scalar
-from strawberry.type import StrawberryType, has_object_definition
+from strawberry.types.base import StrawberryType, has_object_definition
 
 # TypeGuard is only available in typing_extensions => 3.10, we don't want
 # to force updates to the typing_extensions package so we only use it when
@@ -12,7 +12,7 @@ from strawberry.type import StrawberryType, has_object_definition
 if TYPE_CHECKING:
     from typing_extensions import TypeGuard
 
-    from strawberry.custom_scalar import ScalarDefinition, ScalarWrapper
+    from strawberry.types.scalar import ScalarDefinition, ScalarWrapper
 
 
 def is_input_type(type_: Union[StrawberryType, type]) -> TypeGuard[type]:
@@ -51,3 +51,13 @@ def is_graphql_generic(type_: Union[StrawberryType, type]) -> bool:
         return type_.is_graphql_generic
 
     return False
+
+
+__all__ = [
+    "is_input_type",
+    "is_interface_type",
+    "is_scalar",
+    "is_enum",
+    "is_schema_directive",
+    "is_graphql_generic",
+]

strawberry/schema/config.py

@@ -20,3 +20,6 @@ class StrawberryConfig:
     ) -> None:
         if auto_camel_case is not None:
             self.name_converter.auto_camel_case = auto_camel_case
+
+
+__all__ = ["StrawberryConfig"]

strawberry/schema/exceptions.py

@@ -13,3 +13,6 @@ class InvalidOperationTypeError(Exception):
         }[self.operation_type]
 
         return f"{operation_type} are not allowed when using {method}"
+
+
+__all__ = ["InvalidOperationTypeError"]

strawberry/schema/execute.py

@@ -277,3 +277,6 @@ def execute_sync(
         errors=execution_context.result.errors,
         extensions=extensions_runner.get_extensions_results_sync(),
     )
+
+
+__all__ = ["execute", "execute_sync"]

strawberry/schema/name_converter.py

@@ -3,25 +3,25 @@ from __future__ import annotations
 from typing import TYPE_CHECKING, List, Optional, Union, cast
 from typing_extensions import Protocol
 
-from strawberry.custom_scalar import ScalarDefinition
 from strawberry.directive import StrawberryDirective
-from strawberry.enum import EnumDefinition, EnumValue
-from strawberry.lazy_type import LazyType
 from strawberry.schema_directive import StrawberrySchemaDirective
-from strawberry.type import (
+from strawberry.types.base import (
     StrawberryList,
+    StrawberryObjectDefinition,
     StrawberryOptional,
     has_object_definition,
 )
-from strawberry.types.types import StrawberryObjectDefinition
-from strawberry.union import StrawberryUnion
+from strawberry.types.enum import EnumDefinition, EnumValue
+from strawberry.types.lazy_type import LazyType
+from strawberry.types.scalar import ScalarDefinition
+from strawberry.types.union import StrawberryUnion
 from strawberry.utils.str_converters import capitalize_first, to_camel_case
 from strawberry.utils.typing import eval_type
 
 if TYPE_CHECKING:
-    from strawberry.arguments import StrawberryArgument
-    from strawberry.field import StrawberryField
-    from strawberry.type import StrawberryType
+    from strawberry.types.arguments import StrawberryArgument
+    from strawberry.types.base import StrawberryType
+    from strawberry.types.field import StrawberryField
 
 
 class HasGraphQLName(Protocol):
@@ -184,3 +184,6 @@ class NameConverter:
         assert obj.python_name
 
         return self.apply_naming_config(obj.python_name)
+
+
+__all__ = ["NameConverter"]

strawberry/schema/schema.py

@@ -36,10 +36,9 @@ from strawberry.extensions.directives import (
 )
 from strawberry.schema.schema_converter import GraphQLCoreConverter
 from strawberry.schema.types.scalar import DEFAULT_SCALAR_REGISTRY
-from strawberry.type import has_object_definition
 from strawberry.types import ExecutionContext
+from strawberry.types.base import StrawberryObjectDefinition, has_object_definition
 from strawberry.types.graphql import OperationType
-from strawberry.types.types import StrawberryObjectDefinition
 
 from ..printer import print_schema
 from . import compat
@@ -51,14 +50,14 @@ if TYPE_CHECKING:
     from graphql import ExecutionContext as GraphQLExecutionContext
     from graphql import ExecutionResult as GraphQLExecutionResult
 
-    from strawberry.custom_scalar import ScalarDefinition, ScalarWrapper
     from strawberry.directive import StrawberryDirective
-    from strawberry.enum import EnumDefinition
     from strawberry.extensions import SchemaExtension
-    from strawberry.field import StrawberryField
-    from strawberry.type import StrawberryType
     from strawberry.types import ExecutionResult
-    from strawberry.union import StrawberryUnion
+    from strawberry.types.base import StrawberryType
+    from strawberry.types.enum import EnumDefinition
+    from strawberry.types.field import StrawberryField
+    from strawberry.types.scalar import ScalarDefinition, ScalarWrapper
+    from strawberry.types.union import StrawberryUnion
 
 DEFAULT_ALLOWED_OPERATION_TYPES = {
     OperationType.QUERY,
@@ -81,10 +80,45 @@ class Schema(BaseSchema):
         execution_context_class: Optional[Type[GraphQLExecutionContext]] = None,
         config: Optional[StrawberryConfig] = None,
         scalar_overrides: Optional[
-            Dict[object, Union[Type, ScalarWrapper, ScalarDefinition]]
+            Dict[object, Union[Type, ScalarWrapper, ScalarDefinition]],
         ] = None,
         schema_directives: Iterable[object] = (),
     ) -> None:
+        """Default Schema to be to be used in a Strawberry application.
+
+        A GraphQL Schema class used to define the structure and configuration
+        of GraphQL queries, mutations, and subscriptions.
+
+        This class allows the creation of a GraphQL schema by specifying the types
+        for queries, mutations, and subscriptions, along with various configuration
+        options such as directives, extensions, and scalar overrides.
+
+        Args:
+            query: The entry point for queries.
+            mutation: The entry point for mutations.
+            subscription: The entry point for subscriptions.
+            directives: A list of operation directives that clients can use.
+                The bult-in `@include` and `@skip` are included by default.
+            types: A list of additional types that will be included in the schema.
+            extensions: A list of Strawberry extensions.
+            execution_context_class: The execution context class.
+            config: The configuration for the schema.
+            scalar_overrides: A dictionary of overrides for scalars.
+            schema_directives: A list of schema directives for the schema.
+
+        Example:
+        ```python
+        import strawberry
+
+
+        @strawberry.type
+        class Query:
+            name: str = "Patrick"
+
+
+        schema = strawberry.Schema(query=Query)
+        ```
+        """
         self.query = query
         self.mutation = mutation
         self.subscription = subscription
@@ -395,7 +429,7 @@ class Schema(BaseSchema):
     __str__ = as_str
 
     def introspect(self) -> Dict[str, Any]:
-        """Return the introspection query result for the current schema
+        """Return the introspection query result for the current schema.
 
         Raises:
             ValueError: If the introspection query fails due to an invalid schema
@@ -405,3 +439,6 @@ class Schema(BaseSchema):
             raise ValueError(f"Invalid Schema. Errors {introspection.errors!r}")
 
         return introspection.data
+
+
+__all__ = ["Schema"]