strawberry-graphql 0.227.0__tar.gz → 0.227.0.dev1713463204__tar.gz

{strawberry_graphql-0.227.0 → strawberry_graphql-0.227.0.dev1713463204}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: strawberry-graphql
-Version: 0.227.0
+Version: 0.227.0.dev1713463204
 Summary: A library for creating GraphQL APIs
 Home-page: https://strawberry.rocks/
 License: MIT
@@ -44,7 +44,6 @@ Requires-Dist: chalice (>=1.22,<2.0) ; extra == "chalice"
 Requires-Dist: channels (>=3.0.5) ; extra == "channels"
 Requires-Dist: fastapi (>=0.65.2) ; extra == "fastapi"
 Requires-Dist: flask (>=1.1) ; extra == "flask"
-Requires-Dist: graphlib_backport ; (python_version < "3.9") and (extra == "cli")
 Requires-Dist: graphql-core (>=3.2.0,<3.3.0)
 Requires-Dist: libcst (>=0.4.7) ; extra == "debug" or extra == "debug-server" or extra == "cli"
 Requires-Dist: litestar (>=2) ; (python_version >= "3.8") and (extra == "litestar")

{strawberry_graphql-0.227.0 → strawberry_graphql-0.227.0.dev1713463204}/pyproject.toml

@@ -1,7 +1,7 @@
 [tool.poetry]
 name = "strawberry-graphql"
 packages = [ { include = "strawberry" } ]
-version = "0.227.0"
+version = "0.227.0.dev.1713463204"
 description = "A library for creating GraphQL APIs"
 authors = ["Patrick Arminio <patrick.arminio@gmail.com>"]
 license = "MIT"
@@ -61,14 +61,13 @@ astunparse = {version = "^1.6.3", python = "<3.9"}
 libcst = {version = ">=0.4.7", optional = true}
 rich = {version = ">=12.0.0", optional = true}
 pyinstrument = {version = ">=4.0.0", optional = true}
-graphlib_backport = {version = "*", python = "<3.9", optional = true}
 
 [tool.poetry.group.dev.dependencies]
 asgiref = "^3.2"
-ddtrace = ">=1.6.4"
+ddtrace = ">=1.6.4,<3.0.0"
 email-validator = {version = ">=1.1.3,<3.0.0", optional = false}
 freezegun = "^1.2.1"
-libcst = {version = ">=0.4.7", optional = false}
+libcst = {version = ">=0.4.7,<1.2.0", optional = false}
 MarkupSafe = "2.1.3"
 nox = "^2023.4.22"
 nox-poetry = "^1.0.3"
@@ -77,7 +76,7 @@ opentelemetry-sdk = "<2"
 pygments = "^2.3"
 pyinstrument = {version = ">=4.0.0", optional = false}
 pytest = "^7.2"
-pytest-asyncio = ">=0.20.3"
+pytest-asyncio = ">=0.20.3,<0.24.0"
 pytest-codspeed = "^2.0.1"
 pytest-cov = "^4.0.0"
 pytest-emoji = "^0.2.0"
@@ -85,11 +84,11 @@ pytest-mock = "^3.10"
 pytest-snapshot = "^0.9.0"
 pytest-xdist = {extras = ["psutil"], version = "^3.1.0"}
 python-multipart = ">=0.0.7"
-rich = {version = ">=12.5.1", optional = false}
+rich = {version = ">=12.5.1,<14.0.0", optional = false}
 sanic-testing = ">=22.9,<24.0"
 sentry-sdk = "^1.39.2"
 typer = {version = ">=0.7.0", optional = false}
-types-aiofiles = ">=22.1"
+types-aiofiles = ">=22.1,<24.0"
 types-certifi = "^2021.10.8"
 types-chardet = "^5.0.4"
 types-freezegun = "^1.1.9"
@@ -99,11 +98,11 @@ types-typed-ast = "^1.5.8"
 types-ujson = "^5.6.0"
 types-protobuf = "^4.23.0.1"
 mypy = "1.9.0"
-pytest-mypy-plugins = "3.0.0"
+pytest-mypy-plugins = ">=1.10,<4.0"
 poetry-plugin-export = "^1.6.0"
 # another bug in poetry
 urllib3 = "<2"
-graphlib_backport = {version = "*", python = "<3.9", optional = false}
+ruff = "^0.3.7"
 
 [tool.poetry.group.integrations]
 optional = true
@@ -140,7 +139,7 @@ pydantic = ["pydantic"]
 sanic = ["sanic"]
 fastapi = ["fastapi", "python-multipart"]
 chalice = ["chalice"]
-cli = ["typer", "pygments", "rich", "libcst", "graphlib_backport"]
+cli = ["typer", "pygments", "rich", "libcst"]
 starlite = ["starlite"]
 litestar = ["litestar"]
 pyinstrument = ["pyinstrument"]

{strawberry_graphql-0.227.0 → strawberry_graphql-0.227.0.dev1713463204}/strawberry/__init__.py

@@ -7,7 +7,7 @@ from .enum import enum, enum_value
 from .field import field
 from .lazy_type import LazyType, lazy
 from .mutation import mutation, subscription
-from .object_type import asdict, input, interface, type
+from .object_type import asdict, input, interface, one_of_input, type
 from .parent import Parent
 from .permission import BasePermission
 from .private import Private
@@ -38,6 +38,7 @@ __all__ = [
     "federation",
     "field",
     "input",
+    "one_of_input",
     "interface",
     "mutation",
     "scalar",

{strawberry_graphql-0.227.0 → strawberry_graphql-0.227.0.dev1713463204}/strawberry/ext/mypy_plugin.py

@@ -11,7 +11,6 @@ from typing import (
     List,
     Optional,
     Set,
-    Tuple,
     Union,
     cast,
 )
@@ -60,16 +59,11 @@ try:
 except ImportError:
     TypeVarDef = TypeVarType
 
-PYDANTIC_VERSION: Optional[Tuple[int, ...]] = None
-
 # To be compatible with user who don't use pydantic
 try:
-    import pydantic
     from pydantic.mypy import METADATA_KEY as PYDANTIC_METADATA_KEY
     from pydantic.mypy import PydanticModelField
 
-    PYDANTIC_VERSION = tuple(map(int, pydantic.__version__.split(".")))
-
     from strawberry.experimental.pydantic._compat import IS_PYDANTIC_V1
 except ImportError:
     PYDANTIC_METADATA_KEY = ""
@@ -470,11 +464,6 @@ def strawberry_pydantic_class_callback(ctx: ClassDefContext) -> None:
                     return_type=model_type,
                 )
             else:
-                extra = {}
-
-                if PYDANTIC_VERSION and PYDANTIC_VERSION >= (2, 7, 0):
-                    extra["api"] = ctx.api
-
                 add_method(
                     ctx,
                     "to_pydantic",
@@ -485,7 +474,6 @@ def strawberry_pydantic_class_callback(ctx: ClassDefContext) -> None:
                             typed=True,
                             force_optional=False,
                             use_alias=True,
-                            **extra,
                         )
                         for f in missing_pydantic_fields
                     ],
@@ -499,23 +487,12 @@ def strawberry_pydantic_class_callback(ctx: ClassDefContext) -> None:
             initializer=None,
             kind=ARG_OPT,
         )
-        extra_type = ctx.api.named_type(
-            "builtins.dict",
-            [ctx.api.named_type("builtins.str"), AnyType(TypeOfAny.explicit)],
-        )
-
-        extra_argument = Argument(
-            variable=Var(name="extra", type=UnionType([NoneType(), extra_type])),
-            type_annotation=UnionType([NoneType(), extra_type]),
-            initializer=None,
-            kind=ARG_OPT,
-        )
 
         add_static_method_to_class(
             ctx.api,
             ctx.cls,
             name="from_pydantic",
-            args=[model_argument, extra_argument],
+            args=[model_argument],
             return_type=fill_typevars(ctx.cls.info),
         )
 

{strawberry_graphql-0.227.0 → strawberry_graphql-0.227.0.dev1713463204}/strawberry/object_type.py

@@ -264,6 +264,60 @@ def type(
     return wrap(cls)
 
 
+@overload
+@dataclass_transform(
+    order_default=True, kw_only_default=True, field_specifiers=(field, StrawberryField)
+)
+def one_of_input(
+    cls: T,
+    *,
+    name: Optional[str] = None,
+    description: Optional[str] = None,
+    directives: Optional[Sequence[object]] = (),
+) -> T:
+    ...
+
+
+@overload
+@dataclass_transform(
+    order_default=True, kw_only_default=True, field_specifiers=(field, StrawberryField)
+)
+def one_of_input(
+    *,
+    name: Optional[str] = None,
+    description: Optional[str] = None,
+    directives: Optional[Sequence[object]] = (),
+) -> Callable[[T], T]:
+    ...
+
+
+def one_of_input(
+    cls: Optional[T] = None,
+    *,
+    name: Optional[str] = None,
+    description: Optional[str] = None,
+    directives: Optional[Sequence[object]] = (),
+):
+    """Annotates a class as a GraphQL Input type with the @oneOf directive.
+    Example usage:
+    >>> @strawberry.one_of_input
+    >>> class X:
+    >>>     field_abc: str = "ABC"
+    """
+
+    from strawberry.schema_directives import OneOf
+
+    directives = (*(directives or tuple()), OneOf())
+
+    return type(  # type: ignore # not sure why mypy complains here
+        cls,
+        name=name,
+        description=description,
+        directives=directives,
+        is_input=True,
+    )
+
+
 @overload
 @dataclass_transform(
     order_default=True, kw_only_default=True, field_specifiers=(field, StrawberryField)

{strawberry_graphql-0.227.0 → strawberry_graphql-0.227.0.dev1713463204}/strawberry/schema/execute.py

@@ -23,6 +23,7 @@ from graphql.validation import validate
 
 from strawberry.exceptions import MissingQueryError
 from strawberry.extensions.runner import SchemaExtensionsRunner
+from strawberry.schema.validation_rules.one_of import OneOfInputValidationRule
 from strawberry.types import ExecutionResult
 
 from .exceptions import InvalidOperationTypeError
@@ -55,6 +56,7 @@ def validate_document(
     document: DocumentNode,
     validation_rules: Tuple[Type[ASTValidationRule], ...],
 ) -> List[GraphQLError]:
+    validation_rules += (OneOfInputValidationRule,)
     return validate(
         schema,
         document,

{strawberry_graphql-0.227.0 → strawberry_graphql-0.227.0.dev1713463204}/strawberry/schema/schema.py

@@ -16,6 +16,8 @@ from typing import (
 )
 
 from graphql import (
+    GraphQLBoolean,
+    GraphQLField,
     GraphQLNamedType,
     GraphQLNonNull,
     GraphQLSchema,
@@ -168,6 +170,7 @@ class Schema(BaseSchema):
 
         self._warn_for_federation_directives()
         self._resolve_node_ids()
+        self._extend_introspection()
 
         # Validate schema early because we want developers to know about
         # possible issues as soon as possible
@@ -375,6 +378,14 @@ class Schema(BaseSchema):
                 stacklevel=3,
             )
 
+    def _extend_introspection(self):
+        def _resolve_is_one_of(obj: Any, info: Any) -> bool:
+            return obj.extensions["strawberry-definition"].is_one_of
+
+        instrospection_type = self._schema.type_map["__Type"]
+        instrospection_type.fields["isOneOf"] = GraphQLField(GraphQLBoolean)  # type: ignore[attr-defined]
+        instrospection_type.fields["isOneOf"].resolve = _resolve_is_one_of  # type: ignore[attr-defined]
+
     def as_str(self) -> str:
         return print_schema(self)
 

{strawberry_graphql-0.227.0 → strawberry_graphql-0.227.0.dev1713463204}/strawberry/schema/schema_converter.py

@@ -26,6 +26,7 @@ from graphql import (
     GraphQLDirective,
     GraphQLEnumType,
     GraphQLEnumValue,
+    GraphQLError,
     GraphQLField,
     GraphQLInputField,
     GraphQLInputObjectType,
@@ -410,6 +411,37 @@ class GraphQLCoreConverter:
             assert isinstance(graphql_object_type, GraphQLInputObjectType)  # For mypy
             return graphql_object_type
 
+        def check_one_of(value: dict[str, Any]) -> dict[str, Any]:
+            if len(value) != 1:
+                raise GraphQLError(
+                    f"OneOf Input Object '{type_name}' must specify exactly one key."
+                )
+
+            first_key, first_value = next(iter(value.items()))
+
+            if first_value is None or first_value is UNSET:
+                raise GraphQLError(
+                    f"Value for member field '{first_key}' must be non-null"
+                )
+
+            # We are populating all missing keys with `None`, so users
+            # don't have to set an explicit default for the input type
+            # The alternative is to tell them to use `UNSET`, but it looks
+            # a bit unfriendly to use
+
+            for field in type_definition.fields:
+                name = self.config.name_converter.from_field(field)
+                if name not in value:
+                    value[name] = None
+
+            return value
+
+        out_type = (
+            check_one_of
+            if type_definition.is_input and type_definition.is_one_of
+            else None
+        )
+
         graphql_object_type = GraphQLInputObjectType(
             name=type_name,
             fields=lambda: self.get_graphql_input_fields(type_definition),
@@ -417,6 +449,7 @@ class GraphQLCoreConverter:
             extensions={
                 GraphQLCoreConverter.DEFINITION_BACKREF: type_definition,
             },
+            out_type=out_type,
         )
 
         self.type_map[type_name] = ConcreteType(

strawberry_graphql-0.227.0.dev1713463204/strawberry/schema/validation_rules/one_of.py

@@ -0,0 +1,80 @@
+from typing import Any
+
+from graphql import (
+    ExecutableDefinitionNode,
+    GraphQLError,
+    GraphQLNamedType,
+    ObjectValueNode,
+    ValidationContext,
+    ValidationRule,
+    VariableDefinitionNode,
+    get_named_type,
+)
+
+
+class OneOfInputValidationRule(ValidationRule):
+    def __init__(self, validation_context: ValidationContext) -> None:
+        super().__init__(validation_context)
+
+    def enter_operation_definition(
+        self, node: ExecutableDefinitionNode, *_args: Any
+    ) -> None:
+        self.variable_definitions: dict[str, VariableDefinitionNode] = {}
+
+    def enter_variable_definition(
+        self, node: VariableDefinitionNode, *_args: Any
+    ) -> None:
+        self.variable_definitions[node.variable.name.value] = node
+
+    def enter_object_value(self, node: ObjectValueNode, *_args: Any) -> None:
+        type_ = get_named_type(self.context.get_input_type())
+
+        if not type_:
+            return
+
+        strawberry_type = type_.extensions.get("strawberry-definition")
+
+        if strawberry_type and strawberry_type.is_one_of:
+            self.validate_one_of(node, type_)
+
+    def validate_one_of(self, node: ObjectValueNode, type: GraphQLNamedType) -> None:
+        field_node_map = {field.name.value: field for field in node.fields}
+        keys = list(field_node_map.keys())
+        is_not_exactly_one_field = len(keys) != 1
+
+        if is_not_exactly_one_field:
+            self.report_error(
+                GraphQLError(
+                    f"OneOf Input Object '{type.name}' must specify exactly one key.",
+                    nodes=[node],
+                )
+            )
+
+            return
+
+        value = field_node_map[keys[0]].value
+        is_null_literal = not value or value.kind == "null_value"
+        is_variable = value.kind == "variable"
+
+        if is_null_literal:
+            self.report_error(
+                GraphQLError(
+                    f"Field '{type.name}.{keys[0]}' must be non-null.",
+                    nodes=[node],
+                )
+            )
+
+            return
+
+        if is_variable:
+            variable_name = value.name.value  # type: ignore
+            definition = self.variable_definitions[variable_name]
+            is_nullable_variable = definition.type.kind != "non_null_type"
+
+            if is_nullable_variable:
+                self.report_error(
+                    GraphQLError(
+                        f"Variable '{variable_name}' must be non-nullable to be used for OneOf Input Object '{type.name}'.",
+                        nodes=[node],
+                    )
+                )