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

strawberry/ext/mypy_plugin.py

@@ -92,7 +92,7 @@ FALLBACK_VERSION = Decimal("0.800")
 
 
 class MypyVersion:
-    """Stores the mypy version to be used by the plugin"""
+    """Stores the mypy version to be used by the plugin."""
 
     VERSION: Decimal
 
@@ -330,9 +330,11 @@ def add_static_method_to_class(
     return_type: Type,
     tvar_def: Optional[TypeVarType] = None,
 ) -> None:
-    """Adds a static method
-    Edited add_method_to_class to incorporate static method logic
-    https://github.com/python/mypy/blob/9c05d3d19/mypy/plugins/common.py
+    """Adds a static method.
+
+    Edited `add_method_to_class` to incorporate static method logic
+
+    https://github.com/python/mypy/blob/9c05d3d19/mypy/plugins/common.py.
     """
     info = cls.info
 
@@ -555,22 +557,22 @@ class StrawberryPlugin(Plugin):
         return None
 
     def _is_strawberry_union(self, fullname: str) -> bool:
-        return fullname == "strawberry.union.union" or fullname.endswith(
+        return fullname == "strawberry.types.union.union" or fullname.endswith(
             "strawberry.union"
         )
 
     def _is_strawberry_enum(self, fullname: str) -> bool:
-        return fullname == "strawberry.enum.enum" or fullname.endswith(
+        return fullname == "strawberry.types.enum.enum" or fullname.endswith(
             "strawberry.enum"
         )
 
     def _is_strawberry_scalar(self, fullname: str) -> bool:
-        return fullname == "strawberry.custom_scalar.scalar" or fullname.endswith(
+        return fullname == "strawberry.types.scalar.scalar" or fullname.endswith(
             "strawberry.scalar"
         )
 
     def _is_strawberry_lazy_type(self, fullname: str) -> bool:
-        return fullname == "strawberry.lazy_type.LazyType"
+        return fullname == "strawberry.types.lazy_type.LazyType"
 
     def _is_strawberry_create_type(self, fullname: str) -> bool:
         # using endswith(.create_type) is not ideal as there might be

strawberry/extensions/add_validation_rules.py

@@ -9,31 +9,32 @@ if TYPE_CHECKING:
 
 
 class AddValidationRules(SchemaExtension):
-    """
-    Add graphql-core validation rules
+    """Add graphql-core validation rules.
 
     Example:
-
-    >>> import strawberry
-    >>> from strawberry.extensions import AddValidationRules
-    >>> from graphql import ValidationRule, GraphQLError
-    >>>
-    >>> class MyCustomRule(ValidationRule):
-    ...     def enter_field(self, node, *args) -> None:
-    ...         if node.name.value == "secret_field":
-    ...             self.report_error(
-    ...                 GraphQLError("Can't query field 'secret_field'")
-    ...             )
-    >>>
-    >>> schema = strawberry.Schema(
-    ...     Query,
-    ...     extensions=[
-    ...         AddValidationRules([
-    ...             MyCustomRule,
-    ...         ]),
-    ...     ]
-    ... )
-
+    ```python
+    import strawberry
+    from strawberry.extensions import AddValidationRules
+    from graphql import ValidationRule, GraphQLError
+
+
+    class MyCustomRule(ValidationRule):
+        def enter_field(self, node, *args) -> None:
+            if node.name.value == "secret_field":
+                self.report_error(GraphQLError("Can't query field 'secret_field'"))
+
+
+    schema = strawberry.Schema(
+        Query,
+        extensions=[
+            AddValidationRules(
+                [
+                    MyCustomRule,
+                ]
+            ),
+        ],
+    )
+    ```
     """
 
     validation_rules: List[Type[ASTValidationRule]]
@@ -46,3 +47,6 @@ class AddValidationRules(SchemaExtension):
             self.execution_context.validation_rules + tuple(self.validation_rules)
         )
         yield
+
+
+__all__ = ["AddValidationRules"]

strawberry/extensions/base_extension.py

@@ -27,25 +27,25 @@ class SchemaExtension:
     def on_operation(  # type: ignore
         self,
     ) -> AsyncIteratorOrIterator[None]:  # pragma: no cover
-        """Called before and after a GraphQL operation (query / mutation) starts"""
+        """Called before and after a GraphQL operation (query / mutation) starts."""
         yield None
 
     def on_validate(  # type: ignore
         self,
     ) -> AsyncIteratorOrIterator[None]:  # pragma: no cover
-        """Called before and after the validation step"""
+        """Called before and after the validation step."""
         yield None
 
     def on_parse(  # type: ignore
         self,
     ) -> AsyncIteratorOrIterator[None]:  # pragma: no cover
-        """Called before and after the parsing step"""
+        """Called before and after the parsing step."""
         yield None
 
     def on_execute(  # type: ignore
         self,
     ) -> AsyncIteratorOrIterator[None]:  # pragma: no cover
-        """Called before and after the execution step"""
+        """Called before and after the execution step."""
         yield None
 
     def resolve(
@@ -70,3 +70,5 @@ HOOK_METHODS: Set[str] = {
     SchemaExtension.on_parse.__name__,
     SchemaExtension.on_execute.__name__,
 }
+
+__all__ = ["SchemaExtension", "Hook", "HOOK_METHODS", "LifecycleStep"]

strawberry/extensions/directives.py

@@ -11,8 +11,8 @@ if TYPE_CHECKING:
     from graphql import DirectiveNode, GraphQLResolveInfo
 
     from strawberry.directive import StrawberryDirective
-    from strawberry.field import StrawberryField
     from strawberry.schema.schema import Schema
+    from strawberry.types.field import StrawberryField
     from strawberry.utils.await_maybe import AwaitableOrValue
 
 
@@ -85,3 +85,6 @@ def process_directive(
     if value_parameter:
         arguments[value_parameter.name] = value
     return strawberry_directive, arguments
+
+
+__all__ = ["DirectivesExtension", "DirectivesExtensionSync"]

strawberry/extensions/disable_validation.py

@@ -4,21 +4,21 @@ from strawberry.extensions.base_extension import SchemaExtension
 
 
 class DisableValidation(SchemaExtension):
-    """
-    Disable query validation
+    """Disable query validation.
 
     Example:
 
-    >>> import strawberry
-    >>> from strawberry.extensions import DisableValidation
-    >>>
-    >>> schema = strawberry.Schema(
-    ...     Query,
-    ...     extensions=[
-    ...         DisableValidation,
-    ...     ]
-    ... )
-
+    ```python
+    import strawberry
+    from strawberry.extensions import DisableValidation
+
+    schema = strawberry.Schema(
+        Query,
+        extensions=[
+            DisableValidation,
+        ],
+    )
+    ```
     """
 
     def __init__(self) -> None:
@@ -29,3 +29,6 @@ class DisableValidation(SchemaExtension):
     def on_operation(self) -> Iterator[None]:
         self.execution_context.validation_rules = ()  # remove all validation_rules
         yield
+
+
+__all__ = ["DisableValidation"]

strawberry/extensions/field_extension.py

@@ -7,8 +7,8 @@ from typing import TYPE_CHECKING, Any, Awaitable, Callable, Union
 if TYPE_CHECKING:
     from typing_extensions import TypeAlias
 
-    from strawberry.field import StrawberryField
     from strawberry.types import Info
+    from strawberry.types.field import StrawberryField
 
 
 SyncExtensionResolver: TypeAlias = Callable[..., Any]
@@ -44,7 +44,9 @@ class FieldExtension:
 
 class SyncToAsyncExtension(FieldExtension):
     """Helper class for mixing async extensions with sync resolvers.
-    Applied automatically"""
+
+    Applied automatically.
+    """
 
     async def resolve_async(
         self, next_: AsyncExtensionResolver, source: Any, info: Info, **kwargs: Any
@@ -67,11 +69,12 @@ def _get_async_resolvers(
 def build_field_extension_resolvers(
     field: StrawberryField,
 ) -> list[Union[SyncExtensionResolver, AsyncExtensionResolver]]:
-    """
+    """Builds a list of resolvers for a field with extensions.
+
     Verifies that all of the field extensions for a given field support
     sync or async depending on the field resolver.
-    Inserts a SyncToAsyncExtension to be able to
-    use Async extensions on sync resolvers
+
+    Inserts a SyncToAsyncExtension to be able to use Async extensions on sync resolvers
     Throws a TypeError otherwise.
 
     Returns True if resolving should be async, False on sync resolving
@@ -151,3 +154,6 @@ def build_field_extension_resolvers(
             f"If possible try to change the execution order so that all sync-only "
             f"extensions are executed first."
         )
+
+
+__all__ = ["FieldExtension"]

strawberry/extensions/mask_errors.py

@@ -44,3 +44,6 @@ class MaskErrors(SchemaExtension):
                     processed_errors.append(error)
 
             result.errors = processed_errors
+
+
+__all__ = ["MaskErrors"]

strawberry/extensions/max_aliases.py

@@ -13,36 +13,35 @@ from strawberry.extensions.add_validation_rules import AddValidationRules
 
 
 class MaxAliasesLimiter(AddValidationRules):
-    """
-    Add a validator to limit the number of aliases used.
+    """Add a validator to limit the number of aliases used.
 
     Example:
 
-    >>> import strawberry
-    >>> from strawberry.extensions import MaxAliasesLimiter
-    >>>
-    >>> schema = strawberry.Schema(
-    ...     Query,
-    ...     extensions=[
-    ...         MaxAliasesLimiter(max_alias_count=15)
-    ...     ]
-    ... )
-
-    Arguments:
+    ```python
+    import strawberry
+    from strawberry.extensions import MaxAliasesLimiter
 
-    `max_alias_count: int`
-        The maximum number of aliases allowed in a GraphQL document.
+    schema = strawberry.Schema(Query, extensions=[MaxAliasesLimiter(max_alias_count=15)])
+    ```
     """
 
-    def __init__(
-        self,
-        max_alias_count: int,
-    ) -> None:
+    def __init__(self, max_alias_count: int) -> None:
+        """Initialize the MaxAliasesLimiter.
+
+        Args:
+            max_alias_count: The maximum number of aliases allowed in a GraphQL document.
+        """
         validator = create_validator(max_alias_count)
         super().__init__([validator])
 
 
 def create_validator(max_alias_count: int) -> Type[ValidationRule]:
+    """Create a validator that checks the number of aliases in a document.
+
+    Args:
+        max_alias_count: The maximum number of aliases allowed in a GraphQL document.
+    """
+
     class MaxAliasesValidator(ValidationRule):
         def __init__(self, validation_context: ValidationContext) -> None:
             document = validation_context.document
@@ -82,3 +81,6 @@ def count_fields_with_alias(
             result += count_fields_with_alias(selection)
 
     return result
+
+
+__all__ = ["MaxAliasesLimiter"]

strawberry/extensions/max_tokens.py

@@ -4,25 +4,15 @@ from strawberry.extensions.base_extension import SchemaExtension
 
 
 class MaxTokensLimiter(SchemaExtension):
-    """
-    Add a validator to limit the number of tokens in a GraphQL document.
+    """Add a validator to limit the number of tokens in a GraphQL document.
 
     Example:
+    ```python
+    import strawberry
+    from strawberry.extensions import MaxTokensLimiter
 
-    >>> import strawberry
-    >>> from strawberry.extensions import MaxTokensLimiter
-    >>>
-    >>> schema = strawberry.Schema(
-    ...     Query,
-    ...     extensions=[
-    ...         MaxTokensLimiter(max_token_count=1000)
-    ...     ]
-    ... )
-
-    Arguments:
-
-    `max_token_count: int`
-        The maximum number of tokens allowed in a GraphQL document.
+    schema = strawberry.Schema(Query, extensions=[MaxTokensLimiter(max_token_count=1000)])
+    ```
 
     The following things are counted as tokens:
     * various brackets: "{", "}", "(", ")"
@@ -37,8 +27,16 @@ class MaxTokensLimiter(SchemaExtension):
         self,
         max_token_count: int,
     ) -> None:
+        """Initialize the MaxTokensLimiter.
+
+        Args:
+            max_token_count: The maximum number of tokens allowed in a GraphQL document.
+        """
         self.max_token_count = max_token_count
 
     def on_operation(self) -> Iterator[None]:
         self.execution_context.parse_options["max_tokens"] = self.max_token_count
         yield
+
+
+__all__ = ["MaxTokensLimiter"]

strawberry/extensions/parser_cache.py

@@ -6,31 +6,31 @@ from strawberry.schema.execute import parse_document
 
 
 class ParserCache(SchemaExtension):
-    """
-    Add LRU caching the parsing step during execution to improve performance.
+    """Add LRU caching the parsing step during execution to improve performance.
 
     Example:
 
-    >>> import strawberry
-    >>> from strawberry.extensions import ParserCache
-    >>>
-    >>> schema = strawberry.Schema(
-    ...     Query,
-    ...     extensions=[
-    ...         ParserCache(maxsize=100),
-    ...     ]
-    ... )
-
-    Arguments:
-
-    `maxsize: Optional[int]`
-        Set the maxsize of the cache. If `maxsize` is set to `None` then the
-        cache will grow without bound.
-        More info: https://docs.python.org/3/library/functools.html#functools.lru_cache
-
+    ```python
+    import strawberry
+    from strawberry.extensions import ParserCache
+
+    schema = strawberry.Schema(
+        Query,
+        extensions=[
+            ParserCache(maxsize=100),
+        ],
+    )
+    ```
     """
 
     def __init__(self, maxsize: Optional[int] = None) -> None:
+        """Initialize the ParserCache.
+
+        Args:
+            maxsize: Set the maxsize of the cache. If `maxsize` is set to `None` then the
+                cache will grow without bound.
+                More info: https://docs.python.org/3/library/functools.html#functools.lru_cache
+        """
         self.cached_parse_document = lru_cache(maxsize=maxsize)(parse_document)
 
     def on_parse(self) -> Iterator[None]:
@@ -40,3 +40,6 @@ class ParserCache(SchemaExtension):
             execution_context.query, **execution_context.parse_options
         )
         yield
+
+
+__all__ = ["ParserCache"]

strawberry/extensions/pyinstrument.py

@@ -9,9 +9,7 @@ from strawberry.extensions.base_extension import SchemaExtension
 
 
 class PyInstrument(SchemaExtension):
-    """
-    Extension to profile the execution time of resolvers using PyInstrument.
-    """
+    """Extension to profile the execution time of resolvers using PyInstrument."""
 
     def __init__(
         self,
@@ -20,11 +18,6 @@ class PyInstrument(SchemaExtension):
         self._report_path = report_path
 
     def on_operation(self) -> Iterator[None]:
-        """
-        Called when an operation is started,
-        in this case we start the profiler and yield
-        then we stop the profiler when the operation is done
-        """
         profiler = Profiler()
         profiler.start()
 
@@ -33,3 +26,6 @@ class PyInstrument(SchemaExtension):
         profiler.stop()
 
         Path(self._report_path, encoding="utf-8").write_text(profiler.output_html())
+
+
+__all__ = ["PyInstrument"]

strawberry/extensions/query_depth_limiter.py

@@ -81,32 +81,19 @@ ShouldIgnoreType = Callable[[IgnoreContext], bool]
 
 
 class QueryDepthLimiter(AddValidationRules):
-    """
-    Add a validator to limit the query depth of GraphQL operations
+    """Add a validator to limit the query depth of GraphQL operations.
 
     Example:
 
-    >>> import strawberry
-    >>> from strawberry.extensions import QueryDepthLimiter
-    >>>
-    >>> schema = strawberry.Schema(
-    ...     Query,
-    ...     extensions=[
-    ...         QueryDepthLimiter(max_depth=4)
-    ...     ]
-    ... )
-
-    Arguments:
-
-    `max_depth: int`
-        The maximum allowed depth for any operation in a GraphQL document.
-    `callback: Optional[Callable[[Dict[str, int]], None]`
-        Called each time validation runs. Receives an Object which is a
-        map of the depths for each operation.
-    `should_ignore: Optional[ShouldIgnoreType]`
-        Stops recursive depth checking based on a field name and arguments.
-        A function that returns a boolean and conforms to the ShouldIgnoreType
-        function signature.
+    ```python
+    import strawberry
+    from strawberry.extensions import QueryDepthLimiter
+
+    schema = strawberry.Schema(
+        Query,
+        extensions=[QueryDepthLimiter(max_depth=4)],
+    )
+    ```
     """
 
     def __init__(
@@ -115,6 +102,15 @@ class QueryDepthLimiter(AddValidationRules):
         callback: Optional[Callable[[Dict[str, int]], None]] = None,
         should_ignore: Optional[ShouldIgnoreType] = None,
     ) -> None:
+        """Initialize the QueryDepthLimiter.
+
+        Args:
+            max_depth: The maximum allowed depth for any operation in a GraphQL document.
+            callback: Called each time validation runs.
+                Receives an Object which is a map of the depths for each operation.
+            should_ignore: Stops recursive depth checking based on a field name and arguments.
+                A function that returns a boolean and conforms to the ShouldIgnoreType function signature.
+        """
         if should_ignore is not None and not callable(should_ignore):
             raise TypeError(
                 "The `should_ignore` argument to "
@@ -317,3 +313,6 @@ def is_ignored(node: FieldNode, ignore: Optional[List[IgnoreType]] = None) -> bo
             raise TypeError(f"Invalid ignore option: {rule}")
 
     return False
+
+
+__all__ = ["QueryDepthLimiter"]

strawberry/extensions/runner.py

@@ -84,3 +84,6 @@ class SchemaExtensionsRunner:
         middlewares = tuple(self.extensions) + additional_middlewares
 
         return MiddlewareManager(*middlewares)
+
+
+__all__ = ["SchemaExtensionsRunner"]

strawberry/extensions/tracing/apollo.py

@@ -191,3 +191,6 @@ class ApolloTracingExtensionSync(ApolloTracingExtension):
             end_timestamp = self.now()
             resolver_stats.duration = end_timestamp - start_timestamp
             self._resolver_stats.append(resolver_stats)
+
+
+__all__ = ["ApolloTracingExtension", "ApolloTracingExtensionSync"]

strawberry/extensions/tracing/datadog.py

@@ -43,18 +43,20 @@ class DatadogTracingExtension(SchemaExtension):
         name: str,
         **kwargs: Any,
     ) -> Span:
-        """
-        Create a span with the given name and kwargs.
+        """Create a span with the given name and kwargs.
+
         You can  override this if you want to add more tags to the span.
 
         Example:
 
+        ```python
         class CustomExtension(DatadogTracingExtension):
             def create_span(self, lifecycle_step, name, **kwargs):
                 span = super().create_span(lifecycle_step, name, **kwargs)
                 if lifecycle_step == LifeCycleStep.OPERATION:
                     span.set_tag("graphql.query", self.execution_context.query)
                 return span
+        ```
         """
         return tracer.trace(
             name,
@@ -173,3 +175,6 @@ class DatadogTracingExtensionSync(DatadogTracingExtension):
             span.set_tag("graphql.path", ".".join(map(str, info.path.as_list())))
 
             return _next(root, info, *args, **kwargs)
+
+
+__all__ = ["DatadogTracingExtension", "DatadogTracingExtensionSync"]

strawberry/extensions/tracing/opentelemetry.py

@@ -208,3 +208,6 @@ class OpenTelemetryExtensionSync(OpenTelemetryExtension):
             result = _next(root, info, *args, **kwargs)
 
             return result
+
+
+__all__ = ["OpenTelemetryExtension", "OpenTelemetryExtensionSync"]

strawberry/extensions/tracing/sentry.py

@@ -156,3 +156,6 @@ class SentryTracingExtensionSync(SentryTracingExtension):
             span.set_tag("graphql.path", ".".join(map(str, info.path.as_list())))
 
             return _next(root, info, *args, **kwargs)
+
+
+__all__ = ["SentryTracingExtension", "SentryTracingExtensionSync"]

strawberry/extensions/tracing/utils.py

@@ -18,3 +18,6 @@ def should_skip_tracing(resolver: Callable[..., Any], info: GraphQLResolveInfo)
         or is_default_resolver(resolver)
         or resolver is None
     )
+
+
+__all__ = ["should_skip_tracing"]

strawberry/extensions/utils.py

@@ -35,3 +35,6 @@ def get_path_from_info(info: GraphQLResolveInfo) -> List[str]:
         path = path.prev
 
     return elements[::-1]
+
+
+__all__ = ["is_introspection_key", "is_introspection_field", "get_path_from_info"]

strawberry/extensions/validation_cache.py

@@ -6,31 +6,31 @@ from strawberry.schema.execute import validate_document
 
 
 class ValidationCache(SchemaExtension):
-    """
-    Add LRU caching the validation step during execution to improve performance.
+    """Add LRU caching the validation step during execution to improve performance.
 
     Example:
-
-    >>> import strawberry
-    >>> from strawberry.extensions import ValidationCache
-    >>>
-    >>> schema = strawberry.Schema(
-    ...     Query,
-    ...     extensions=[
-    ...         ValidationCache(maxsize=100),
-    ...     ]
-    ... )
-
-    Arguments:
-
-    `maxsize: Optional[int]`
-        Set the maxsize of the cache. If `maxsize` is set to `None` then the
-        cache will grow without bound.
-        More info: https://docs.python.org/3/library/functools.html#functools.lru_cache
-
+    ```python
+    import strawberry
+    from strawberry.extensions import ValidationCache
+
+    schema = strawberry.Schema(
+        Query,
+        extensions=[
+            ValidationCache(maxsize=100),
+        ],
+    )
+    ```
     """
 
     def __init__(self, maxsize: Optional[int] = None) -> None:
+        """Initialize the ValidationCache.
+
+        Args:
+            maxsize: Set the maxsize of the cache. If `maxsize` is set to `None` then the
+                cache will grow without bound.
+
+        More info: https://docs.python.org/3/library/functools.html#functools.lru_cache
+        """
         self.cached_validate_document = lru_cache(maxsize=maxsize)(validate_document)
 
     def on_validate(self) -> Iterator[None]:
@@ -43,3 +43,6 @@ class ValidationCache(SchemaExtension):
         )
         execution_context.errors = errors
         yield
+
+
+__all__ = ["ValidationCache"]

strawberry/fastapi/context.py

@@ -18,3 +18,6 @@ class BaseContext:
         self.request: Optional[Union[Request, WebSocket]] = None
         self.background_tasks: Optional[BackgroundTasks] = None
         self.response: Optional[Response] = None
+
+
+__all__ = ["BaseContext"]