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

strawberry/subscriptions/protocols/graphql_transport_ws/types.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 from dataclasses import asdict, dataclass
 from typing import TYPE_CHECKING, Any, Dict, List, Optional
 
-from strawberry.unset import UNSET
+from strawberry.types.unset import UNSET
 
 if TYPE_CHECKING:
     from graphql import GraphQLFormattedError
@@ -21,9 +21,7 @@ class GraphQLTransportMessage:
 
 @dataclass
 class ConnectionInitMessage(GraphQLTransportMessage):
-    """
-    Direction: Client -> Server
-    """
+    """Direction: Client -> Server."""
 
     payload: Optional[Dict[str, Any]] = UNSET
     type: str = "connection_init"
@@ -31,9 +29,7 @@ class ConnectionInitMessage(GraphQLTransportMessage):
 
 @dataclass
 class ConnectionAckMessage(GraphQLTransportMessage):
-    """
-    Direction: Server -> Client
-    """
+    """Direction: Server -> Client."""
 
     payload: Optional[Dict[str, Any]] = UNSET
     type: str = "connection_ack"
@@ -41,9 +37,7 @@ class ConnectionAckMessage(GraphQLTransportMessage):
 
 @dataclass
 class PingMessage(GraphQLTransportMessage):
-    """
-    Direction: bidirectional
-    """
+    """Direction: bidirectional."""
 
     payload: Optional[Dict[str, Any]] = UNSET
     type: str = "ping"
@@ -51,9 +45,7 @@ class PingMessage(GraphQLTransportMessage):
 
 @dataclass
 class PongMessage(GraphQLTransportMessage):
-    """
-    Direction: bidirectional
-    """
+    """Direction: bidirectional."""
 
     payload: Optional[Dict[str, Any]] = UNSET
     type: str = "pong"
@@ -69,9 +61,7 @@ class SubscribeMessagePayload:
 
 @dataclass
 class SubscribeMessage(GraphQLTransportMessage):
-    """
-    Direction: Client -> Server
-    """
+    """Direction: Client -> Server."""
 
     id: str
     payload: SubscribeMessagePayload
@@ -80,9 +70,7 @@ class SubscribeMessage(GraphQLTransportMessage):
 
 @dataclass
 class NextMessage(GraphQLTransportMessage):
-    """
-    Direction: Server -> Client
-    """
+    """Direction: Server -> Client."""
 
     id: str
     payload: Dict[str, Any]  # TODO: shape like FormattedExecutionResult
@@ -94,9 +82,7 @@ class NextMessage(GraphQLTransportMessage):
 
 @dataclass
 class ErrorMessage(GraphQLTransportMessage):
-    """
-    Direction: Server -> Client
-    """
+    """Direction: Server -> Client."""
 
     id: str
     payload: List[GraphQLFormattedError]
@@ -105,9 +91,19 @@ class ErrorMessage(GraphQLTransportMessage):
 
 @dataclass
 class CompleteMessage(GraphQLTransportMessage):
-    """
-    Direction: bidirectional
-    """
+    """Direction: bidirectional."""
 
     id: str
     type: str = "complete"
+
+
+__all__ = [
+    "ConnectionInitMessage",
+    "ConnectionAckMessage",
+    "PingMessage",
+    "PongMessage",
+    "SubscribeMessage",
+    "NextMessage",
+    "ErrorMessage",
+    "CompleteMessage",
+]

strawberry/subscriptions/protocols/graphql_ws/__init__.py

@@ -8,3 +8,17 @@ GQL_DATA = "data"
 GQL_ERROR = "error"
 GQL_COMPLETE = "complete"
 GQL_STOP = "stop"
+
+
+__all__ = [
+    "GQL_CONNECTION_INIT",
+    "GQL_CONNECTION_ACK",
+    "GQL_CONNECTION_ERROR",
+    "GQL_CONNECTION_TERMINATE",
+    "GQL_CONNECTION_KEEP_ALIVE",
+    "GQL_START",
+    "GQL_DATA",
+    "GQL_ERROR",
+    "GQL_COMPLETE",
+    "GQL_STOP",
+]

strawberry/subscriptions/protocols/graphql_ws/handlers.py

@@ -51,23 +51,23 @@ class BaseGraphQLWSHandler(ABC):
 
     @abstractmethod
     async def get_context(self) -> Any:
-        """Return the operations context"""
+        """Return the operations context."""
 
     @abstractmethod
     async def get_root_value(self) -> Any:
-        """Return the schemas root value"""
+        """Return the schemas root value."""
 
     @abstractmethod
     async def send_json(self, data: OperationMessage) -> None:
-        """Send the data JSON encoded to the WebSocket client"""
+        """Send the data JSON encoded to the WebSocket client."""
 
     @abstractmethod
     async def close(self, code: int = 1000, reason: Optional[str] = None) -> None:
-        """Close the WebSocket with the passed code and reason"""
+        """Close the WebSocket with the passed code and reason."""
 
     @abstractmethod
     async def handle_request(self) -> Any:
-        """Handle the request this instance was created for"""
+        """Handle the request this instance was created for."""
 
     async def handle(self) -> Any:
         return await self.handle_request()
@@ -208,3 +208,6 @@ class BaseGraphQLWSHandler(ABC):
         if payload is not None:
             data["payload"] = payload
         await self.send_json(data)
+
+
+__all__ = ["BaseGraphQLWSHandler"]

strawberry/subscriptions/protocols/graphql_ws/types.py

@@ -38,3 +38,14 @@ class OperationMessage(TypedDict, total=False):
     type: str
     id: str
     payload: OperationMessagePayload
+
+
+__all__ = [
+    "ConnectionInitPayload",
+    "ConnectionErrorPayload",
+    "StartPayload",
+    "DataPayload",
+    "ErrorPayload",
+    "OperationMessagePayload",
+    "OperationMessage",
+]

strawberry/test/client.py

@@ -91,47 +91,59 @@ class BaseGraphQLTestClient(ABC):
     def _build_multipart_file_map(
         variables: Dict[str, Mapping], files: Dict[str, object]
     ) -> Dict[str, List[str]]:
-        """Creates the file mapping between the variables and the files objects passed
-        as key arguments
+        """Creates the file mapping between the variables and the files objects passed as key arguments.
+
+        Args:
+            variables: A dictionary with the variables that are going to be passed to the
+                query.
+            files: A dictionary with the files that are going to be passed to the query.
 
         Example usages:
 
-        >>> _build_multipart_file_map(
-        >>>     variables={"textFile": None}, files={"textFile": f}
-        >>> )
-        ... {"textFile": ["variables.textFile"]}
+        ```python
+        _build_multipart_file_map(variables={"textFile": None}, files={"textFile": f})
+        # {"textFile": ["variables.textFile"]}
+        ```
 
         If the variable is a list we have to enumerate files in the mapping
-        >>> _build_multipart_file_map(
-        >>>     variables={"files": [None, None]},
-        >>>     files={"file1": file1, "file2": file2},
-        >>> )
-        ... {"file1": ["variables.files.0"], "file2": ["variables.files.1"]}
+
+        ```python
+        _build_multipart_file_map(
+            variables={"files": [None, None]},
+            files={"file1": file1, "file2": file2},
+        )
+        # {"file1": ["variables.files.0"], "file2": ["variables.files.1"]}
+        ```
 
         If `variables` contains another keyword (a folder) we must include that keyword
         in the mapping
-        >>> _build_multipart_file_map(
-        >>>     variables={"folder": {"files": [None, None]}},
-        >>>     files={"file1": file1, "file2": file2},
-        >>> )
-        ... {
-        ...     "file1": ["variables.files.folder.files.0"],
-        ...     "file2": ["variables.files.folder.files.1"]
-        ... }
+
+        ```python
+        _build_multipart_file_map(
+            variables={"folder": {"files": [None, None]}},
+            files={"file1": file1, "file2": file2},
+        )
+        # {
+        #     "file1": ["variables.files.folder.files.0"],
+        #     "file2": ["variables.files.folder.files.1"]
+        # }
+        ```
 
         If `variables` includes both a list of files and other single values, we must
         map them accordingly
-        >>> _build_multipart_file_map(
-        >>>     variables={"files": [None, None], "textFile": None},
-        >>>     files={"file1": file1, "file2": file2, "textFile": file3},
-        >>> )
-        ... {
-        ...     "file1": ["variables.files.0"],
-        ...     "file2": ["variables.files.1"],
-        ...     "textFile": ["variables.textFile"],
-        ... }
-        """
 
+        ```python
+        _build_multipart_file_map(
+            variables={"files": [None, None], "textFile": None},
+            files={"file1": file1, "file2": file2, "textFile": file3},
+        )
+        # {
+        #     "file1": ["variables.files.0"],
+        #     "file2": ["variables.files.1"],
+        #     "textFile": ["variables.textFile"],
+        # }
+        ```
+        """
         map: Dict[str, List[str]] = {}
         for key, values in variables.items():
             reference = key
@@ -167,3 +179,6 @@ class BaseGraphQLTestClient(ABC):
         if type == "multipart":
             return json.loads(response.content.decode())
         return response.json()
+
+
+__all__ = ["BaseGraphQLTestClient", "Response", "Body"]

strawberry/tools/create_type.py

@@ -2,7 +2,7 @@ import types
 from typing import List, Optional, Sequence, Type
 
 import strawberry
-from strawberry.field import StrawberryField
+from strawberry.types.field import StrawberryField
 
 
 def create_type(
@@ -14,15 +14,31 @@ def create_type(
     directives: Optional[Sequence[object]] = (),
     extend: bool = False,
 ) -> Type:
-    """Create a Strawberry type from a list of StrawberryFields
+    """Create a Strawberry type from a list of StrawberryFields.
 
-    >>> @strawberry.field
-    >>> def hello(info) -> str:
-    >>>     return "World"
-    >>>
-    >>> Query = create_type(name="Query", fields=[hello])
-    """
+    Args:
+        name: The GraphQL name of the type.
+        fields: The fields of the type.
+        is_input: Whether the type is an input type.
+        is_interface: Whether the type is an interface.
+        description: The GraphQL description of the type.
+        directives: The directives to attach to the type.
+        extend: Whether the type is an extension.
+
+    Example usage:
+
+    ```python
+    import strawberry
+
+
+    @strawberry.field
+    def hello(info) -> str:
+        return "World"
 
+
+    Query = create_type(name="Query", fields=[hello])
+    ```
+    """
     if not fields:
         raise ValueError(f'Can\'t create type "{name}" with no fields')
 
@@ -55,3 +71,6 @@ def create_type(
         directives=directives,
         extend=extend,
     )
+
+
+__all__ = ["create_type"]

strawberry/tools/merge_types.py

@@ -4,11 +4,11 @@ from itertools import chain
 from typing import Tuple
 
 import strawberry
-from strawberry.type import has_object_definition
+from strawberry.types.base import has_object_definition
 
 
 def merge_types(name: str, types: Tuple[type, ...]) -> type:
-    """Merge multiple Strawberry types into one
+    """Merge multiple Strawberry types into one.
 
     For example, given two queries `A` and `B`, one can merge them into a
     super type as follows:
@@ -20,7 +20,6 @@ def merge_types(name: str, types: Tuple[type, ...]) -> type:
         class SuperQuery(B, A):
             ...
     """
-
     if not types:
         raise ValueError("Can't merge types if none are supplied")
 
@@ -35,3 +34,6 @@ def merge_types(name: str, types: Tuple[type, ...]) -> type:
         )
 
     return strawberry.type(type(name, types, {}))
+
+
+__all__ = ["merge_types"]

strawberry/types/__init__.py

@@ -1,4 +1,11 @@
+from .base import get_object_definition, has_object_definition
 from .execution import ExecutionContext, ExecutionResult
 from .info import Info
 
-__all__ = ["ExecutionContext", "ExecutionResult", "Info"]
+__all__ = [
+    "ExecutionContext",
+    "ExecutionResult",
+    "Info",
+    "get_object_definition",
+    "has_object_definition",
+]

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

@@ -16,25 +16,28 @@ from typing import (
 from typing_extensions import Annotated, get_args, get_origin
 
 from strawberry.annotation import StrawberryAnnotation
-from strawberry.enum import EnumDefinition
-from strawberry.lazy_type import LazyType, StrawberryLazyReference
-from strawberry.type import StrawberryList, StrawberryOptional, has_object_definition
-
-from .exceptions import MultipleStrawberryArgumentsError, UnsupportedTypeError
-from .scalars import is_scalar
-from .unset import UNSET as _deprecated_UNSET
-from .unset import _deprecated_is_unset  # noqa # type: ignore
+from strawberry.exceptions import MultipleStrawberryArgumentsError, UnsupportedTypeError
+from strawberry.scalars import is_scalar
+from strawberry.types.base import (
+    StrawberryList,
+    StrawberryOptional,
+    has_object_definition,
+)
+from strawberry.types.enum import EnumDefinition
+from strawberry.types.lazy_type import LazyType, StrawberryLazyReference
+from strawberry.types.unset import UNSET as _deprecated_UNSET
+from strawberry.types.unset import _deprecated_is_unset  # noqa # type: ignore
 
 if TYPE_CHECKING:
-    from strawberry.custom_scalar import ScalarDefinition, ScalarWrapper
     from strawberry.schema.config import StrawberryConfig
-    from strawberry.type import StrawberryType
+    from strawberry.types.base import StrawberryType
+    from strawberry.types.scalar import ScalarDefinition, ScalarWrapper
 
 
 DEPRECATED_NAMES: Dict[str, str] = {
     "UNSET": (
         "importing `UNSET` from `strawberry.arguments` is deprecated, "
-        "import instead from `strawberry` or from `strawberry.unset`"
+        "import instead from `strawberry` or from `strawberry.types.unset`"
     ),
     "is_unset": "`is_unset` is deprecated use `value is UNSET` instead",
 }
@@ -202,8 +205,8 @@ def convert_arguments(
     """Converts a nested dictionary to a dictionary of actual types.
 
     It deals with conversion of input types to proper dataclasses and
-    also uses a sentinel value for unset values."""
-
+    also uses a sentinel value for unset values.
+    """
     if not arguments:
         return {}
 
@@ -234,6 +237,34 @@ def argument(
     directives: Iterable[object] = (),
     metadata: Optional[Mapping[Any, Any]] = None,
 ) -> StrawberryArgumentAnnotation:
+    """Function to add metadata to an argument, like a description or deprecation reason.
+
+    Args:
+        description: The GraphQL description of the argument
+        name: The GraphQL name of the argument
+        deprecation_reason: The reason why this argument is deprecated,
+            setting this will mark the argument as deprecated
+        directives: The directives to attach to the argument
+        metadata: Metadata to attach to the argument, this can be used
+            to store custom data that can be used by custom logic or plugins
+
+    Returns:
+        A StrawberryArgumentAnnotation object that can be used to customise an argument
+
+    Example:
+    ```python
+    import strawberry
+
+
+    @strawberry.type
+    class Query:
+        @strawberry.field
+        def example(
+            self, info, value: int = strawberry.argument(description="The value")
+        ) -> int:
+            return value
+    ```
+    """
     return StrawberryArgumentAnnotation(
         description=description,
         name=name,

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

@@ -3,9 +3,8 @@ from __future__ import annotations
 from typing import Any, Optional, Union, cast
 from typing_extensions import Annotated, get_args, get_origin
 
-from strawberry.type import StrawberryType
-
-from .annotation import StrawberryAnnotation
+from strawberry.annotation import StrawberryAnnotation
+from strawberry.types.base import StrawberryType
 
 
 class StrawberryAutoMeta(type):
@@ -77,3 +76,22 @@ class StrawberryAuto(metaclass=StrawberryAutoMeta):
 
 
 auto = Annotated[Any, StrawberryAuto()]
+"""Special marker for automatic annotation.
+
+A special value that can be used to automatically infer the type of a field
+when using integrations like Strawberry Django or Strawberry Pydantic.
+
+Example:
+```python
+import strawberry
+
+from my_user_app import models
+
+
+@strawberry.django.type(models.User)
+class User:
+    name: strawberry.auto
+```
+"""
+
+__all__ = ["auto"]