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

strawberry/codemods/update_imports.py

@@ -0,0 +1,136 @@
+from __future__ import annotations
+
+import libcst as cst
+import libcst.matchers as m
+from libcst.codemod import CodemodContext, VisitorBasedCodemodCommand
+from libcst.codemod.visitors import AddImportsVisitor, RemoveImportsVisitor
+
+
+class UpdateImportsCodemod(VisitorBasedCodemodCommand):
+    def __init__(self, context: CodemodContext) -> None:
+        super().__init__(context)
+        self.add_imports_visitor = AddImportsVisitor(context)
+        self.remove_imports_visitor = RemoveImportsVisitor(context)
+
+    def _update_imports(
+        self, node: cst.ImportFrom, updated_node: cst.ImportFrom
+    ) -> cst.ImportFrom:
+        imports = [
+            "field",
+            "union",
+            "auto",
+            "unset",
+            "arguments",
+            "lazy_type",
+            "object_type",
+            "private",
+            "enum",
+        ]
+
+        for import_name in imports:
+            if m.matches(
+                node,
+                m.ImportFrom(
+                    module=m.Attribute(
+                        value=m.Name("strawberry"), attr=m.Name(import_name)
+                    )
+                ),
+            ):
+                updated_node = updated_node.with_changes(
+                    module=cst.Attribute(
+                        value=cst.Attribute(
+                            value=cst.Name("strawberry"), attr=cst.Name("types")
+                        ),
+                        attr=cst.Name(import_name),
+                    ),
+                )
+
+        return updated_node
+
+    def _update_types_types_imports(
+        self, node: cst.ImportFrom, updated_node: cst.ImportFrom
+    ) -> cst.ImportFrom:
+        if m.matches(
+            node,
+            m.ImportFrom(
+                module=m.Attribute(
+                    value=m.Attribute(value=m.Name("strawberry"), attr=m.Name("types")),
+                    attr=m.Name("types"),
+                )
+            ),
+        ):
+            updated_node = updated_node.with_changes(
+                module=cst.Attribute(
+                    value=cst.Attribute(
+                        value=cst.Name("strawberry"), attr=cst.Name("types")
+                    ),
+                    attr=cst.Name("base"),
+                ),
+            )
+
+        return updated_node
+
+    def _update_strawberry_type_imports(
+        self, node: cst.ImportFrom, updated_node: cst.ImportFrom
+    ) -> cst.ImportFrom:
+        if m.matches(
+            node,
+            m.ImportFrom(
+                module=m.Attribute(value=m.Name("strawberry"), attr=m.Name("type"))
+            ),
+        ):
+            has_get_object_definition = (
+                any(
+                    m.matches(name, m.ImportAlias(name=m.Name("get_object_definition")))
+                    for name in node.names
+                )
+                if not isinstance(node.names, cst.ImportStar)
+                else False
+            )
+
+            has_has_object_definition = (
+                any(
+                    m.matches(name, m.ImportAlias(name=m.Name("has_object_definition")))
+                    for name in node.names
+                )
+                if not isinstance(node.names, cst.ImportStar)
+                else False
+            )
+
+            updated_node = updated_node.with_changes(
+                module=cst.Attribute(
+                    value=cst.Attribute(
+                        value=cst.Name("strawberry"), attr=cst.Name("types")
+                    ),
+                    attr=cst.Name("base"),
+                ),
+            )
+
+            self.remove_imports_visitor.remove_unused_import(
+                self.context, "strawberry.types.base", "get_object_definition"
+            )
+
+            self.remove_imports_visitor.remove_unused_import(
+                self.context, "strawberry.types.base", "has_object_definition"
+            )
+
+            if has_get_object_definition:
+                self.add_imports_visitor.add_needed_import(
+                    self.context, "strawberry.types", "get_object_definition"
+                )
+
+            if has_has_object_definition:
+                self.add_imports_visitor.add_needed_import(
+                    self.context, "strawberry.types", "has_object_definition"
+                )
+
+        return updated_node
+
+    def leave_ImportFrom(
+        self, node: cst.ImportFrom, updated_node: cst.ImportFrom
+    ) -> cst.ImportFrom:
+        updated_node = self._update_imports(updated_node, updated_node)
+        updated_node = self._update_types_types_imports(updated_node, updated_node)
+        updated_node = self._update_strawberry_type_imports(updated_node, updated_node)
+
+        return updated_node

strawberry/dataloader.py

@@ -267,3 +267,16 @@ async def dispatch_batch(loader: DataLoader, batch: Batch) -> None:
     except Exception as e:
         for task in batch.tasks:
             task.future.set_exception(e)
+
+
+__all__ = [
+    "DataLoader",
+    "Batch",
+    "LoaderTask",
+    "AbstractCache",
+    "DefaultCache",
+    "should_create_new_batch",
+    "get_current_batch",
+    "dispatch",
+    "dispatch_batch",
+]

strawberry/directive.py

@@ -7,21 +7,45 @@ from typing_extensions import Annotated
 
 from graphql import DirectiveLocation
 
-from strawberry.field import StrawberryField
+from strawberry.types.field import StrawberryField
 from strawberry.types.fields.resolver import (
     INFO_PARAMSPEC,
     ReservedType,
     StrawberryResolver,
 )
-from strawberry.unset import UNSET
+from strawberry.types.unset import UNSET
 
 if TYPE_CHECKING:
     import inspect
 
-    from strawberry.arguments import StrawberryArgument
+    from strawberry.types.arguments import StrawberryArgument
 
 
-def directive_field(name: str, default: object = UNSET) -> Any:
+# TODO: should this be directive argument?
+def directive_field(
+    name: str,
+    default: object = UNSET,
+) -> Any:
+    """Function to add metadata to a directive argument, like the GraphQL name.
+
+    Args:
+        name: The GraphQL name of the directive argument
+        default: The default value of the argument
+
+    Returns:
+        A StrawberryField object that can be used to customise a directive argument
+
+    Example:
+    ```python
+    import strawberry
+    from strawberry.schema_directive import Location
+
+
+    @strawberry.schema_directive(locations=[Location.FIELD_DEFINITION])
+    class Sensitive:
+        reason: str = strawberry.directive_field(name="as")
+    ```
+    """
     return StrawberryField(
         python_name=None,
         graphql_name=name,
@@ -74,6 +98,30 @@ def directive(
     description: Optional[str] = None,
     name: Optional[str] = None,
 ) -> Callable[[Callable[..., T]], StrawberryDirective[T]]:
+    """Decorator to create a GraphQL operation directive.
+
+    Args:
+        locations: The locations where the directive can be used
+        description: The GraphQL description of the directive
+        name: The GraphQL name of the directive
+
+    Returns:
+        A StrawberryDirective object that can be used to customise a directive
+
+    Example:
+    ```python
+    import strawberry
+    from strawberry.directive import DirectiveLocation
+
+
+    @strawberry.directive(
+        locations=[DirectiveLocation.FIELD], description="Make string uppercase"
+    )
+    def turn_uppercase(value: str):
+        return value.upper()
+    ```
+    """
+
     def _wrap(f: Callable[..., T]) -> StrawberryDirective[T]:
         return StrawberryDirective(
             python_name=f.__name__,

strawberry/django/context.py

@@ -18,5 +18,8 @@ class StrawberryDjangoContext:
         return super().__getattribute__(key)
 
     def get(self, key: str) -> Any:
-        """Enable .get notation for accessing the request"""
+        """Enable .get notation for accessing the request."""
         return super().__getattribute__(key)
+
+
+__all__ = ["StrawberryDjangoContext"]

strawberry/django/test/client.py

@@ -18,3 +18,6 @@ class GraphQLTestClient(BaseGraphQLTestClient):
         return self._client.post(
             self.url, data=body, content_type="application/json", headers=headers
         )
+
+
+__all__ = ["GraphQLTestClient"]

strawberry/django/views.py

@@ -287,3 +287,6 @@ class AsyncGraphQLView(
         response.content = template.render(RequestContext(request, context))
 
         return response
+
+
+__all__ = ["GraphQLView", "AsyncGraphQLView"]

strawberry/exceptions/__init__.py

@@ -25,7 +25,7 @@ from .unresolved_field_type import UnresolvedFieldTypeError
 if TYPE_CHECKING:
     from graphql import GraphQLInputObjectType, GraphQLObjectType
 
-    from strawberry.type import StrawberryType
+    from strawberry.types.base import StrawberryType
 
     from .exception_source import ExceptionSource
 
@@ -34,7 +34,7 @@ setup_exception_handler()
 
 # TODO: this doesn't seem to be tested
 class WrongReturnTypeForUnion(Exception):
-    """The Union type cannot be resolved because it's not a field"""
+    """The Union type cannot be resolved because it's not a field."""
 
     def __init__(self, field_name: str, result_type: str) -> None:
         message = (
@@ -46,7 +46,7 @@ class WrongReturnTypeForUnion(Exception):
 
 
 class UnallowedReturnTypeForUnion(Exception):
-    """The return type is not in the list of Union types"""
+    """The return type is not in the list of Union types."""
 
     def __init__(
         self, field_name: str, result_type: str, allowed_types: Set[GraphQLObjectType]
@@ -144,7 +144,7 @@ class InvalidDefaultFactoryError(Exception):
 
 
 class InvalidCustomContext(Exception):
-    """Raised when a custom context object is of the wrong python type"""
+    """Raised when a custom context object is of the wrong python type."""
 
     def __init__(self) -> None:
         message = (
@@ -155,7 +155,7 @@ class InvalidCustomContext(Exception):
 
 
 class StrawberryGraphQLError(GraphQLError):
-    """Use it when you want to override the graphql.GraphQLError in custom extensions"""
+    """Use it when you want to override the graphql.GraphQLError in custom extensions."""
 
 
 __all__ = [

strawberry/exceptions/duplicated_type_name.py

@@ -13,7 +13,7 @@ if TYPE_CHECKING:
 
 
 class DuplicatedTypeName(StrawberryException):
-    """Raised when the same type with different definition is reused inside a schema"""
+    """Raised when the same type with different definition is reused inside a schema."""
 
     def __init__(
         self,

strawberry/exceptions/invalid_argument_type.py

@@ -3,13 +3,13 @@ from __future__ import annotations
 from functools import cached_property
 from typing import TYPE_CHECKING, Optional
 
-from strawberry.type import get_object_definition
+from strawberry.types.base import get_object_definition
 
 from .exception import StrawberryException
 from .utils.source_finder import SourceFinder
 
 if TYPE_CHECKING:
-    from strawberry.arguments import StrawberryArgument
+    from strawberry.types.arguments import StrawberryArgument
     from strawberry.types.fields.resolver import StrawberryResolver
 
     from .exception_source import ExceptionSource
@@ -21,7 +21,7 @@ class InvalidArgumentTypeError(StrawberryException):
         resolver: StrawberryResolver,
         argument: StrawberryArgument,
     ) -> None:
-        from strawberry.union import StrawberryUnion
+        from strawberry.types.union import StrawberryUnion
 
         self.function = resolver.wrapped_func
         self.argument_name = argument.python_name

strawberry/exceptions/invalid_union_type.py

@@ -10,13 +10,13 @@ from strawberry.exceptions.utils.source_finder import SourceFinder
 from .exception import StrawberryException
 
 if TYPE_CHECKING:
-    from strawberry.union import StrawberryUnion
+    from strawberry.types.union import StrawberryUnion
 
     from .exception_source import ExceptionSource
 
 
 class InvalidUnionTypeError(StrawberryException):
-    """The union is constructed with an invalid type"""
+    """The union is constructed with an invalid type."""
 
     invalid_type: object
 
@@ -26,8 +26,8 @@ class InvalidUnionTypeError(StrawberryException):
         invalid_type: object,
         union_definition: Optional[StrawberryUnion] = None,
     ) -> None:
-        from strawberry.custom_scalar import ScalarWrapper
-        from strawberry.type import StrawberryList
+        from strawberry.types.base import StrawberryList
+        from strawberry.types.scalar import ScalarWrapper
 
         self.union_name = union_name
         self.invalid_type = invalid_type
@@ -78,8 +78,7 @@ class InvalidUnionTypeError(StrawberryException):
 
 
 class InvalidTypeForUnionMergeError(StrawberryException):
-    """A specialized version of InvalidUnionTypeError for when trying
-    to merge unions using the pipe operator."""
+    """A specialized version of InvalidUnionTypeError for when trying to merge unions using the pipe operator."""
 
     invalid_type: Type
 

strawberry/exceptions/missing_arguments_annotations.py

@@ -13,7 +13,7 @@ if TYPE_CHECKING:
 
 
 class MissingArgumentsAnnotationsError(StrawberryException):
-    """The field is missing the annotation for one or more arguments"""
+    """The field is missing the annotation for one or more arguments."""
 
     def __init__(
         self,

strawberry/exceptions/missing_dependencies.py

@@ -4,8 +4,7 @@ from typing import Optional
 
 
 class MissingOptionalDependenciesError(Exception):
-    """Some optional dependencies that are required for a particular
-    task are missing."""
+    """Some optional dependencies that are required for a particular task are missing."""
 
     def __init__(
         self,
@@ -13,8 +12,17 @@ class MissingOptionalDependenciesError(Exception):
         packages: Optional[list[str]] = None,
         extras: Optional[list[str]] = None,
     ) -> None:
+        """Initialize the error.
+
+        Args:
+            packages: List of packages that are required but missing.
+            extras: List of extras that are required but missing.
+        """
         packages = packages or []
+
         if extras:
             packages.append(f"'strawberry-graphql[{','.join(extras)}]'")
+
         hint = f" (hint: pip install {' '.join(packages)})" if packages else ""
+
         self.message = f"Some optional dependencies are missing{hint}"

strawberry/exceptions/missing_return_annotation.py

@@ -13,7 +13,7 @@ if TYPE_CHECKING:
 
 
 class MissingReturnAnnotationError(StrawberryException):
-    """The field is missing the return annotation"""
+    """The field is missing the return annotation."""
 
     def __init__(
         self,

strawberry/exceptions/permission_fail_silently_requires_optional.py

@@ -20,7 +20,7 @@ class PermissionFailSilentlyRequiresOptionalError(StrawberryException):
         self.rich_message = (
             "fail_silently permissions can only be used with fields of type "
             f"optional or list. Provided field `[underline]{field.name}[/]` "
-            f"is of type `[underline]{field.type.__name__}[/]`"  # type: ignore
+            f"is of type `[underline]{field.type.__name__}[/]`"
         )
         self.annotation_message = "field defined here"
         self.suggestion = (
@@ -38,14 +38,14 @@ class PermissionFailSilentlyRequiresOptionalError(StrawberryException):
         source = None
         if origin is not None:
             source = source_finder.find_class_attribute_from_object(
-                origin,  # type: ignore
+                origin,
                 self.field.python_name,
             )
 
         # in case it is a function
         if source is None and self.field.base_resolver is not None:
             source = source_finder.find_function_from_object(
-                self.field.base_resolver.wrapped_func  # type: ignore
+                self.field.base_resolver.wrapped_func
             )
 
         return source

strawberry/exceptions/scalar_already_registered.py

@@ -9,7 +9,7 @@ from strawberry.exceptions.utils.source_finder import SourceFinder
 from .exception import StrawberryException
 
 if TYPE_CHECKING:
-    from strawberry.custom_scalar import ScalarDefinition
+    from strawberry.types.scalar import ScalarDefinition
 
     from .exception_source import ExceptionSource
 

strawberry/exceptions/unresolved_field_type.py

@@ -8,8 +8,8 @@ from strawberry.exceptions.utils.source_finder import SourceFinder
 from .exception import StrawberryException
 
 if TYPE_CHECKING:
-    from strawberry.field import StrawberryField
-    from strawberry.object_type import StrawberryObjectDefinition
+    from strawberry.types.field import StrawberryField
+    from strawberry.types.object_type import StrawberryObjectDefinition
 
     from .exception_source import ExceptionSource
 

strawberry/exceptions/utils/source_finder.py

@@ -15,8 +15,8 @@ if TYPE_CHECKING:
 
     from libcst import BinaryOperation, Call, CSTNode, FunctionDef
 
-    from strawberry.custom_scalar import ScalarDefinition
-    from strawberry.union import StrawberryUnion
+    from strawberry.types.scalar import ScalarDefinition
+    from strawberry.types.union import StrawberryUnion
 
 
 @dataclass
@@ -605,3 +605,6 @@ class SourceFinder:
             if self.cst
             else None
         )
+
+
+__all__ = ["SourceFinder"]

strawberry/experimental/pydantic/conversion.py

@@ -4,17 +4,17 @@ import copy
 import dataclasses
 from typing import TYPE_CHECKING, Any, Type, Union, cast
 
-from strawberry.enum import EnumDefinition
-from strawberry.type import (
+from strawberry.types.base import (
     StrawberryList,
     StrawberryOptional,
     has_object_definition,
 )
-from strawberry.union import StrawberryUnion
+from strawberry.types.enum import EnumDefinition
+from strawberry.types.union import StrawberryUnion
 
 if TYPE_CHECKING:
-    from strawberry.field import StrawberryField
-    from strawberry.type import StrawberryType
+    from strawberry.types.base import StrawberryType
+    from strawberry.types.field import StrawberryField
 
 
 def _convert_from_pydantic_to_strawberry_type(

strawberry/experimental/pydantic/conversion_types.py

@@ -6,7 +6,7 @@ from typing_extensions import Protocol
 from pydantic import BaseModel
 
 if TYPE_CHECKING:
-    from strawberry.types.types import StrawberryObjectDefinition
+    from strawberry.types.base import StrawberryObjectDefinition
 
 
 PydanticModel = TypeVar("PydanticModel", bound=BaseModel)
@@ -14,7 +14,9 @@ PydanticModel = TypeVar("PydanticModel", bound=BaseModel)
 
 class StrawberryTypeFromPydantic(Protocol[PydanticModel]):
     """This class does not exist in runtime.
-    It only makes the methods below visible for IDEs"""
+
+    It only makes the methods below visible for IDEs.
+    """
 
     def __init__(self, **kwargs: Any) -> None: ...
 

strawberry/experimental/pydantic/error_type.py

@@ -16,7 +16,6 @@ from typing import (
 
 from pydantic import BaseModel
 
-from strawberry.auto import StrawberryAuto
 from strawberry.experimental.pydantic._compat import (
     CompatModelField,
     PydanticCompat,
@@ -27,7 +26,8 @@ from strawberry.experimental.pydantic.utils import (
     get_strawberry_type_from_model,
     normalize_type,
 )
-from strawberry.object_type import _process_type, _wrap_dataclass
+from strawberry.types.auto import StrawberryAuto
+from strawberry.types.object_type import _process_type, _wrap_dataclass
 from strawberry.types.type_resolver import _get_fields
 from strawberry.utils.typing import get_list_annotation, is_list
 

strawberry/experimental/pydantic/fields.py

@@ -13,7 +13,7 @@ from strawberry.experimental.pydantic._compat import (
 from strawberry.experimental.pydantic.exceptions import (
     UnregisteredTypeException,
 )
-from strawberry.types.types import StrawberryObjectDefinition
+from strawberry.types.base import StrawberryObjectDefinition
 
 try:
     from types import UnionType as TypingUnionType
@@ -51,7 +51,7 @@ def replace_pydantic_types(type_: Any, is_input: bool) -> Any:
 def replace_types_recursively(
     type_: Any, is_input: bool, compat: PydanticCompat
 ) -> Any:
-    """Runs the conversions recursively into the arguments of generic types if any"""
+    """Runs the conversions recursively into the arguments of generic types if any."""
     basic_type = compat.get_basic_type(type_)
     replaced_type = replace_pydantic_types(basic_type, is_input)
 

strawberry/experimental/pydantic/object_type.py

@@ -17,7 +17,6 @@ from typing import (
 )
 
 from strawberry.annotation import StrawberryAnnotation
-from strawberry.auto import StrawberryAuto
 from strawberry.experimental.pydantic._compat import (
     CompatModelField,
     PydanticCompat,
@@ -34,8 +33,9 @@ from strawberry.experimental.pydantic.utils import (
     get_default_factory_for_field,
     get_private_fields,
 )
-from strawberry.field import StrawberryField
-from strawberry.object_type import _process_type, _wrap_dataclass
+from strawberry.types.auto import StrawberryAuto
+from strawberry.types.field import StrawberryField
+from strawberry.types.object_type import _process_type, _wrap_dataclass
 from strawberry.types.type_resolver import _get_fields
 from strawberry.utils.dataclasses import add_custom_init_fn
 
@@ -312,8 +312,10 @@ def input(
     use_pydantic_alias: bool = True,
 ) -> Callable[..., Type[StrawberryTypeFromPydantic[PydanticModel]]]:
     """Convenience decorator for creating an input type from a Pydantic model.
-    Equal to partial(type, is_input=True)
-    See https://github.com/strawberry-graphql/strawberry/issues/1830
+
+    Equal to `partial(type, is_input=True)`
+
+    See https://github.com/strawberry-graphql/strawberry/issues/1830.
     """
     return type(
         model=model,
@@ -340,8 +342,10 @@ def interface(
     use_pydantic_alias: bool = True,
 ) -> Callable[..., Type[StrawberryTypeFromPydantic[PydanticModel]]]:
     """Convenience decorator for creating an interface type from a Pydantic model.
-    Equal to partial(type, is_interface=True)
-    See https://github.com/strawberry-graphql/strawberry/issues/1830
+
+    Equal to `partial(type, is_interface=True)`
+
+    See https://github.com/strawberry-graphql/strawberry/issues/1830.
     """
     return type(
         model=model,

strawberry/experimental/pydantic/utils.py

@@ -25,8 +25,8 @@ from strawberry.experimental.pydantic.exceptions import (
     BothDefaultAndDefaultFactoryDefinedError,
     UnregisteredTypeException,
 )
-from strawberry.private import is_private
-from strawberry.unset import UNSET
+from strawberry.types.private import is_private
+from strawberry.types.unset import UNSET
 from strawberry.utils.typing import (
     get_list_annotation,
     get_optional_annotation,
@@ -60,7 +60,7 @@ def get_private_fields(cls: Type) -> List[dataclasses.Field]:
 
 
 class DataclassCreationFields(NamedTuple):
-    """Fields required for the fields parameter of make_dataclass"""
+    """Fields required for the fields parameter of make_dataclass."""
 
     name: str
     field_type: Type
@@ -75,8 +75,7 @@ def get_default_factory_for_field(
     field: CompatModelField,
     compat: PydanticCompat,
 ) -> Union[NoArgAnyCallable, dataclasses._MISSING_TYPE]:
-    """
-    Gets the default factory for a pydantic field.
+    """Gets the default factory for a pydantic field.
 
     Handles mutable defaults when making the dataclass by
     using pydantic's smart_deepcopy

strawberry/ext/dataclasses/dataclasses.py

@@ -21,7 +21,8 @@ def dataclass_init_fn(
     self_name: str,
     globals_: Dict[str, Any],
 ) -> Any:
-    """
+    """Create an __init__ function for a dataclass.
+
     We create a custom __init__ function for the dataclasses that back
     Strawberry object types to only accept keyword arguments. This allows us to
     avoid the problem where a type cannot define a field with a default value