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

strawberry/parent.py

@@ -8,31 +8,37 @@ class StrawberryParent: ...
 T = TypeVar("T")
 
 Parent = Annotated[T, StrawberryParent()]
-Parent.__doc__ = """Represents a parameter holding the parent resolver's value.
+"""Represents a parameter holding the parent resolver's value.
 
 This can be used when defining a resolver on a type when the parent isn't expected
 to return the type itself.
 
 Example:
 
->>> import strawberry
->>> from dataclasses import dataclass
->>>
->>> @dataclass
->>> class UserRow:
-...     id_: str
-...
->>> @strawberry.type
-... class User:
-...     @strawberry.field
-...     @staticmethod
-...     async def name(parent: strawberry.Parent[UserRow]) -> str:
-...         return f"User Number {parent.id}"
-...
->>> @strawberry.type
->>> class Query:
-...     @strawberry.field
-...     def user(self) -> User:
-...         return UserRow(id_="1234")
-...
+```python
+import strawberry
+from dataclasses import dataclass
+
+
+@dataclass
+class UserRow:
+    id_: str
+
+
+@strawberry.type
+class User:
+    @strawberry.field
+    @staticmethod
+    async def name(parent: strawberry.Parent[UserRow]) -> str:
+        return f"User Number {parent.id_}"
+
+
+@strawberry.type
+class Query:
+    @strawberry.field
+    def user(self) -> User:
+        return UserRow(id_="1234")
+```
 """
+
+__all__ = ["Parent"]

strawberry/permission.py

@@ -21,7 +21,7 @@ from strawberry.exceptions.permission_fail_silently_requires_optional import (
 )
 from strawberry.extensions import FieldExtension
 from strawberry.schema_directive import Location, StrawberrySchemaDirective
-from strawberry.type import StrawberryList, StrawberryOptional
+from strawberry.types.base import StrawberryList, StrawberryOptional
 from strawberry.utils.await_maybe import await_maybe
 
 if TYPE_CHECKING:
@@ -31,13 +31,25 @@ if TYPE_CHECKING:
         AsyncExtensionResolver,
         SyncExtensionResolver,
     )
-    from strawberry.field import StrawberryField
     from strawberry.types import Info
+    from strawberry.types.field import StrawberryField
 
 
 class BasePermission(abc.ABC):
-    """
-    Base class for creating permissions
+    """Base class for permissions. All permissions should inherit from this class.
+
+    Example:
+
+    ```python
+    from strawberry.permission import BasePermission
+
+
+    class IsAuthenticated(BasePermission):
+        message = "User is not authenticated"
+
+        def has_permission(self, source, info, **kwargs):
+            return info.context["user"].is_authenticated
+    ```
     """
 
     message: Optional[str] = None
@@ -52,16 +64,39 @@ class BasePermission(abc.ABC):
     def has_permission(
         self, source: Any, info: Info, **kwargs: Any
     ) -> Union[bool, Awaitable[bool]]:
+        """Check if the permission should be accepted.
+
+        This method should be overridden by the subclasses.
+        """
         raise NotImplementedError(
             "Permission classes should override has_permission method"
         )
 
     def on_unauthorized(self) -> None:
-        """
-        Default error raising for permissions.
-        This can be overridden to customize the behavior.
-        """
+        """Default error raising for permissions.
+
+        This method can be overridden to customize the error raised when the permission is not granted.
+
+        Example:
+
+        ```python
+        from strawberry.permission import BasePermission
+
+
+        class CustomPermissionError(PermissionError):
+            pass
+
 
+        class IsAuthenticated(BasePermission):
+            message = "User is not authenticated"
+
+            def has_permission(self, source, info, **kwargs):
+                return info.context["user"].is_authenticated
+
+            def on_unauthorized(self) -> None:
+                raise CustomPermissionError(self.message)
+        ```
+        """
         # Instantiate error class
         error = self.error_class(self.message or "")
 
@@ -91,17 +126,14 @@ class BasePermission(abc.ABC):
 
 
 class PermissionExtension(FieldExtension):
-    """
-    Handles permissions for a field
-    Instantiate this as a field extension with all of the permissions you want to apply
+    """Handles permissions for a field.
 
-    fail_silently: bool = False will return None or [] if the permission fails
-    instead of raising an exception. This is only valid for optional or list fields.
+    Instantiate this as a field extension with all of the permissions you want to apply.
 
-    NOTE:
-    Currently, this is automatically added to the field, when using
-    field.permission_classes
-    This is deprecated behavior, please manually add the extension to field.extensions
+    Note:
+        Currently, this is automatically added to the field, when using field.permission_classes
+
+    This is deprecated behaviour, please manually add the extension to field.extensions
     """
 
     def __init__(
@@ -110,16 +142,21 @@ class PermissionExtension(FieldExtension):
         use_directives: bool = True,
         fail_silently: bool = False,
     ) -> None:
+        """Initialize the permission extension.
+
+        Args:
+            permissions: List of permissions to apply.
+            fail_silently: If True, return None or [] instead of raising an exception.
+                This is only valid for optional or list fields.
+            use_directives: If True, add schema directives to the field.
+        """
         self.permissions = permissions
         self.fail_silently = fail_silently
         self.return_empty_list = False
         self.use_directives = use_directives
 
     def apply(self, field: StrawberryField) -> None:
-        """
-        Applies all of the permission directives to the schema
-        and sets up silent permissions
-        """
+        """Applies all of the permission directives to the schema and sets up silent permissions."""
         if self.use_directives:
             field.directives.extend(
                 p.schema_directive for p in self.permissions if p.schema_directive
@@ -147,10 +184,7 @@ class PermissionExtension(FieldExtension):
         info: Info,
         **kwargs: Dict[str, Any],
     ) -> Any:
-        """
-        Checks if the permission should be accepted and
-        raises an exception if not
-        """
+        """Checks if the permission should be accepted and raises an exception if not."""
         for permission in self.permissions:
             if not permission.has_permission(source, info, **kwargs):
                 return self._on_unauthorized(permission)
@@ -177,11 +211,20 @@ class PermissionExtension(FieldExtension):
 
     @cached_property
     def supports_sync(self) -> bool:
-        """The Permission extension always supports async checking using await_maybe,
-        but only supports sync checking if there are no async permissions"""
+        """Whether this extension can be resolved synchronously or not.
+
+        The Permission extension always supports async checking using await_maybe,
+        but only supports sync checking if there are no async permissions.
+        """
         async_permissions = [
             True
             for permission in self.permissions
             if iscoroutinefunction(permission.has_permission)
         ]
         return len(async_permissions) == 0
+
+
+__all__ = [
+    "BasePermission",
+    "PermissionExtension",
+]

strawberry/printer/ast_from_value.py

@@ -27,7 +27,7 @@ from graphql.type import (
 )
 
 import strawberry
-from strawberry.type import has_object_definition
+from strawberry.types.base import has_object_definition
 
 if TYPE_CHECKING:
     from graphql.language import ValueNode
@@ -149,3 +149,6 @@ def ast_from_value(value: Any, type_: GraphQLInputType) -> Optional[ValueNode]:
 
     # Not reachable. All possible input types have been considered.
     raise TypeError(f"Unexpected input type: {inspect(type_)}.")  # pragma: no cover
+
+
+__all__ = ["ast_from_value"]

strawberry/printer/printer.py

@@ -37,11 +37,11 @@ from graphql.utilities.print_schema import (
 )
 from graphql.utilities.print_schema import print_type as original_print_type
 
-from strawberry.custom_scalar import ScalarWrapper
-from strawberry.enum import EnumDefinition
 from strawberry.schema_directive import Location, StrawberrySchemaDirective
-from strawberry.type import StrawberryContainer, has_object_definition
-from strawberry.unset import UNSET
+from strawberry.types.base import StrawberryContainer, has_object_definition
+from strawberry.types.enum import EnumDefinition
+from strawberry.types.scalar import ScalarWrapper
+from strawberry.types.unset import UNSET
 
 from .ast_from_value import ast_from_value
 
@@ -55,8 +55,8 @@ if TYPE_CHECKING:
     )
     from graphql.type.directives import GraphQLDirective
 
-    from strawberry.field import StrawberryField
     from strawberry.schema import BaseSchema
+    from strawberry.types.field import StrawberryField
 
 
 _T = TypeVar("_T")
@@ -588,3 +588,6 @@ def print_schema(schema: BaseSchema) -> str:
             ),
         )
     )
+
+
+__all__ = ["print_schema"]

strawberry/quart/views.py

@@ -102,3 +102,6 @@ class GraphQLView(
                 response=e.reason,
                 status=e.status_code,
             )
+
+
+__all__ = ["GraphQLView"]

strawberry/relay/exceptions.py

@@ -102,3 +102,10 @@ class RelayWrongResolverAnnotationError(StrawberryException):
 
         source_finder = SourceFinder()
         return source_finder.find_function_from_object(cast(Callable, self.function))
+
+
+__all__ = [
+    "NodeIDAnnotationError",
+    "RelayWrongAnnotationError",
+    "RelayWrongResolverAnnotationError",
+]

strawberry/relay/fields.py

@@ -29,20 +29,20 @@ from typing import (
 from typing_extensions import Annotated, get_origin
 
 from strawberry.annotation import StrawberryAnnotation
-from strawberry.arguments import StrawberryArgument, argument
 from strawberry.extensions.field_extension import (
     AsyncExtensionResolver,
     FieldExtension,
     SyncExtensionResolver,
 )
-from strawberry.field import _RESOLVER_TYPE, StrawberryField, field
-from strawberry.lazy_type import LazyType
 from strawberry.relay.exceptions import (
     RelayWrongAnnotationError,
     RelayWrongResolverAnnotationError,
 )
-from strawberry.type import StrawberryList, StrawberryOptional
+from strawberry.types.arguments import StrawberryArgument, argument
+from strawberry.types.base import StrawberryList, StrawberryOptional
+from strawberry.types.field import _RESOLVER_TYPE, StrawberryField, field
 from strawberry.types.fields.resolver import StrawberryResolver
+from strawberry.types.lazy_type import LazyType
 from strawberry.utils.aio import asyncgen_to_list
 from strawberry.utils.typing import eval_type, is_generic_alias
 
@@ -62,7 +62,7 @@ class NodeExtension(FieldExtension):
         if isinstance(field.type, StrawberryList):
             resolver = self.get_node_list_resolver(field)
         else:
-            resolver = self.get_node_resolver(field)
+            resolver = self.get_node_resolver(field)  # type: ignore
 
         field.base_resolver = StrawberryResolver(resolver, type_override=field.type)
 
@@ -81,7 +81,9 @@ class NodeExtension(FieldExtension):
         # async extensions.
         return await retval if inspect.isawaitable(retval) else retval
 
-    def get_node_resolver(self, field: StrawberryField):  # noqa: ANN201
+    def get_node_resolver(
+        self, field: StrawberryField
+    ) -> Callable[[Info, GlobalID], Union[Node, None, Awaitable[Union[Node, None]]]]:
         type_ = field.type
         is_optional = isinstance(type_, StrawberryOptional)
 
@@ -97,7 +99,9 @@ class NodeExtension(FieldExtension):
 
         return resolver
 
-    def get_node_list_resolver(self, field: StrawberryField):  # noqa: ANN201
+    def get_node_list_resolver(
+        self, field: StrawberryField
+    ) -> Callable[[Info, List[GlobalID]], Union[List[Node], Awaitable[List[Node]]]]:
         type_ = field.type
         assert isinstance(type_, StrawberryList)
         is_optional = isinstance(type_.of_type, StrawberryOptional)
@@ -390,48 +394,66 @@ def connection(
     case for this is to provide a filtered iterable of nodes by using some custom
     filter arguments.
 
+    Args:
+        graphql_type: The type of the nodes in the connection. This is used to
+            determine the type of the edges and the node field in the connection.
+        resolver: The resolver for the connection. This is expected to return an
+            iterable of the expected node type.
+        name: The GraphQL name of the field.
+        is_subscription: Whether the field is a subscription.
+        description: The GraphQL description of the field.
+        permission_classes: The permission classes to apply to the field.
+        deprecation_reason: The deprecation reason of the field.
+        default: The default value of the field.
+        default_factory: The default factory of the field.
+        metadata: The metadata of the field.
+        directives: The directives to apply to the field.
+        extensions: The extensions to apply to the field.
+        init: Used only for type checking purposes.
+
     Examples:
-        Annotating something like this:
-
-        >>> @strawberry.type
-        >>> class X:
-        ...     some_node: relay.Connection[SomeType] = relay.connection(
-                    resolver=get_some_nodes,
-        ...         description="ABC",
-        ...     )
-        ...
-        ...     @relay.connection(relay.Connection[SomeType], description="ABC")
-        ...     def get_some_nodes(self, age: int) -> Iterable[SomeType]:
-        ...         ...
-
-        Will produce a query like this:
-
-        ```
-        query {
-            someNode (
-                before: String
-                after: String
-                first: String
-                after: String
-                age: Int
-            ) {
-                totalCount
-                pageInfo {
-                    hasNextPage
-                    hasPreviousPage
-                    startCursor
-                    endCursor
-                }
-                edges {
-                    cursor
-                    node {
-                        id
-                        ...
-                    }
+    Annotating something like this:
+
+    ```python
+    @strawberry.type
+    class X:
+        some_node: relay.Connection[SomeType] = relay.connection(
+            resolver=get_some_nodes,
+            description="ABC",
+        )
+
+        @relay.connection(relay.Connection[SomeType], description="ABC")
+        def get_some_nodes(self, age: int) -> Iterable[SomeType]: ...
+    ```
+
+    Will produce a query like this:
+
+    ```graphql
+    query {
+        someNode (
+            before: String
+            after: String
+            first: String
+            after: String
+            age: Int
+        ) {
+            totalCount
+            pageInfo {
+                hasNextPage
+                hasPreviousPage
+                startCursor
+                endCursor
+            }
+            edges {
+                cursor
+                node {
+                    id
+                    ...
                 }
             }
         }
-        ```
+    }
+    ```
 
     .. _Relay connections:
         https://relay.dev/graphql/connections.htm
@@ -454,3 +476,6 @@ def connection(
     if resolver is not None:
         f = f(resolver)
     return f
+
+
+__all__ = ["node", "connection"]