strawberry-graphql 0.186.0__tar.gz → 0.186.2__tar.gz

{strawberry_graphql-0.186.0 → strawberry_graphql-0.186.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: strawberry-graphql
-Version: 0.186.0
+Version: 0.186.2
 Summary: A library for creating GraphQL APIs
 Home-page: https://strawberry.rocks/
 License: MIT

{strawberry_graphql-0.186.0 → strawberry_graphql-0.186.2}/pyproject.toml

@@ -1,7 +1,7 @@
 [tool.poetry]
 name = "strawberry-graphql"
 packages = [ { include = "strawberry" } ]
-version = "0.186.0"
+version = "0.186.2"
 description = "A library for creating GraphQL APIs"
 authors = ["Patrick Arminio <patrick.arminio@gmail.com>"]
 license = "MIT"

{strawberry_graphql-0.186.0 → strawberry_graphql-0.186.2}/strawberry/codegen/plugins/python.py

@@ -8,6 +8,7 @@ from typing import TYPE_CHECKING, Dict, List, Optional, Set
 from strawberry.codegen import CodegenFile, QueryCodegenPlugin
 from strawberry.codegen.types import (
     GraphQLEnum,
+    GraphQLEnumValue,
     GraphQLList,
     GraphQLObjectType,
     GraphQLOptional,
@@ -16,7 +17,12 @@ from strawberry.codegen.types import (
 )
 
 if TYPE_CHECKING:
-    from strawberry.codegen.types import GraphQLField, GraphQLOperation, GraphQLType
+    from strawberry.codegen.types import (
+        GraphQLArgumentValue,
+        GraphQLField,
+        GraphQLOperation,
+        GraphQLType,
+    )
 
 
 @dataclass
@@ -104,7 +110,40 @@ class PythonPlugin(QueryCodegenPlugin):
         if field.alias:
             name = f"# alias for {field.name}\n{field.alias}"
 
-        return f"{name}: {self._get_type_name(field.type)}"
+        default_value = ""
+        if field.default_value is not None:
+            default_value = f" = {self._print_argument_value(field.default_value)}"
+        return f"{name}: {self._get_type_name(field.type)}{default_value}"
+
+    def _print_argument_value(self, argval: GraphQLArgumentValue) -> str:
+        if hasattr(argval, "values"):
+            if isinstance(argval.values, list):
+                return (
+                    "["
+                    + ", ".join(self._print_argument_value(v) for v in argval.values)
+                    + "]"
+                )
+            elif isinstance(argval.values, dict):
+                return (
+                    "{"
+                    + ", ".join(
+                        f"{k!r}: {self._print_argument_value(v)}"
+                        for k, v in argval.values.items()
+                    )
+                    + "}"
+                )
+            else:
+                raise TypeError(f"Unrecognized values type: {argval}")
+        if isinstance(argval, GraphQLEnumValue):
+            # This is an enum.  It needs the namespace alongside the name.
+            if argval.enum_type is None:
+                raise ValueError(
+                    "GraphQLEnumValue must have a type for python code gen. {argval}"
+                )
+            return f"{argval.enum_type}.{argval.name}"
+        if not hasattr(argval, "value"):
+            raise TypeError(f"Unrecognized values type: {argval}")
+        return repr(argval.value)
 
     def _print_enum_value(self, value: str) -> str:
         return f'{value} = "{value}"'

{strawberry_graphql-0.186.0 → strawberry_graphql-0.186.2}/strawberry/codegen/query_codegen.py

@@ -1,13 +1,17 @@
 from __future__ import annotations
 
-from dataclasses import dataclass
+from dataclasses import MISSING, dataclass
+from enum import Enum
 from functools import cmp_to_key, partial
 from typing import (
     TYPE_CHECKING,
+    Any,
     Callable,
     Iterable,
     List,
+    Mapping,
     Optional,
+    Sequence,
     Tuple,
     Type,
     Union,
@@ -19,6 +23,7 @@ from graphql import (
     BooleanValueNode,
     EnumValueNode,
     FieldNode,
+    FloatValueNode,
     FragmentDefinitionNode,
     FragmentSpreadNode,
     InlineFragmentNode,
@@ -27,6 +32,7 @@ from graphql import (
     ListValueNode,
     NamedTypeNode,
     NonNullTypeNode,
+    NullValueNode,
     ObjectValueNode,
     OperationDefinitionNode,
     StringValueNode,
@@ -55,12 +61,14 @@ from .types import (
     GraphQLEnumValue,
     GraphQLField,
     GraphQLFieldSelection,
+    GraphQLFloatValue,
     GraphQLFragmentSpread,
     GraphQLFragmentType,
     GraphQLInlineFragment,
     GraphQLIntValue,
     GraphQLList,
     GraphQLListValue,
+    GraphQLNullValue,
     GraphQLObjectType,
     GraphQLObjectValue,
     GraphQLOperation,
@@ -154,6 +162,30 @@ def _get_deps(t: GraphQLType) -> Iterable[GraphQLType]:
         raise ValueError(f"Unknown GraphQLType: {t}")
 
 
+_TYPE_TO_GRAPHQL_TYPE = {
+    int: GraphQLIntValue,
+    float: GraphQLFloatValue,
+    str: GraphQLStringValue,
+    bool: GraphQLBoolValue,
+}
+
+
+def _py_to_graphql_value(obj: Any) -> GraphQLArgumentValue:
+    """Convert a python object to a GraphQLArgumentValue."""
+    if obj is None:
+        return GraphQLNullValue()
+    obj_type = type(obj)
+    if obj_type in _TYPE_TO_GRAPHQL_TYPE:
+        return _TYPE_TO_GRAPHQL_TYPE[obj_type](obj)
+    if issubclass(obj_type, Enum):
+        return GraphQLEnumValue(obj.name, enum_type=obj_type.__name__)
+    if issubclass(obj_type, Sequence):
+        return GraphQLListValue([_py_to_graphql_value(v) for v in obj])
+    if issubclass(obj_type, Mapping):
+        return GraphQLObjectValue({k: _py_to_graphql_value(v) for k, v in obj.items()})
+    raise ValueError(f"Cannot convet {obj!r} into a GraphQLArgumentValue")
+
+
 class QueryCodegenPluginManager:
     def __init__(self, plugins: List[QueryCodegenPlugin]) -> None:
         self.plugins = plugins
@@ -307,6 +339,12 @@ class QueryCodegen:
         if isinstance(value, IntValueNode):
             return GraphQLIntValue(int(value.value))
 
+        if isinstance(value, FloatValueNode):
+            return GraphQLFloatValue(float(value.value))
+
+        if isinstance(value, NullValueNode):
+            return GraphQLNullValue()
+
         if isinstance(value, VariableNode):
             return GraphQLVariableReference(value.name.value)
 
@@ -409,7 +447,6 @@ class QueryCodegen:
             )
 
             type_.fields.append(GraphQLField(variable.name, None, variable_type))
-
             variables.append(variable)
 
         return variables, type_
@@ -478,7 +515,12 @@ class QueryCodegen:
 
             for field in strawberry_type.fields:
                 field_type = self._collect_type_from_strawberry_type(field.type)
-                type_.fields.append(GraphQLField(field.name, None, field_type))
+                default = None
+                if field.default is not MISSING:
+                    default = _py_to_graphql_value(field.default)
+                type_.fields.append(
+                    GraphQLField(field.name, None, field_type, default_value=default)
+                )
 
             self._collect_type(type_)
         else:

{strawberry_graphql-0.186.0 → strawberry_graphql-0.186.2}/strawberry/codegen/types.py

@@ -29,6 +29,7 @@ class GraphQLField:
     name: str
     alias: Optional[str]
     type: GraphQLType
+    default_value: Optional[GraphQLArgumentValue] = None
 
 
 @dataclass
@@ -111,9 +112,15 @@ class GraphQLIntValue:
     value: int
 
 
+@dataclass
+class GraphQLFloatValue:
+    value: float
+
+
 @dataclass
 class GraphQLEnumValue:
     name: str
+    enum_type: Optional[str] = None
 
 
 @dataclass
@@ -121,6 +128,13 @@ class GraphQLBoolValue:
     value: bool
 
 
+@dataclass
+class GraphQLNullValue:
+    """A class that represents a GraphQLNull value."""
+
+    value: None = None
+
+
 @dataclass
 class GraphQLListValue:
     values: List[GraphQLArgumentValue]
@@ -138,8 +152,10 @@ class GraphQLVariableReference:
 
 GraphQLArgumentValue = Union[
     GraphQLStringValue,
+    GraphQLNullValue,
     GraphQLIntValue,
     GraphQLVariableReference,
+    GraphQLFloatValue,
     GraphQLListValue,
     GraphQLEnumValue,
     GraphQLBoolValue,

{strawberry_graphql-0.186.0 → strawberry_graphql-0.186.2}/strawberry/field.py

@@ -320,7 +320,7 @@ class StrawberryField(dataclasses.Field):
             else None
         )
 
-        return type(self)(
+        new_field = type(self)(
             python_name=self.python_name,
             graphql_name=self.graphql_name,
             # TODO: do we need to wrap this in `StrawberryAnnotation`?
@@ -330,13 +330,16 @@ class StrawberryField(dataclasses.Field):
             is_subscription=self.is_subscription,
             description=self.description,
             base_resolver=new_resolver,
-            permission_classes=self.permission_classes,
+            permission_classes=self.permission_classes and self.permission_classes[:],
             default=self.default_value,
             # ignored because of https://github.com/python/mypy/issues/6910
             default_factory=self.default_factory,
             deprecation_reason=self.deprecation_reason,
-            directives=self.directives,
+            directives=self.directives and self.directives[:],
+            extensions=self.extensions and self.extensions[:],
         )
+        new_field._arguments = self._arguments and self._arguments[:]
+        return new_field
 
     @property
     def _has_async_permission_classes(self) -> bool:

{strawberry_graphql-0.186.0 → strawberry_graphql-0.186.2}/strawberry/types/types.py

@@ -79,8 +79,8 @@ class TypeDefinition(StrawberryType):
             is_input=self.is_input,
             origin=self.origin,
             is_interface=self.is_interface,
-            directives=self.directives,
-            interfaces=self.interfaces,
+            directives=self.directives and self.directives[:],
+            interfaces=self.interfaces and self.interfaces[:],
             description=self.description,
             extend=self.extend,
             is_type_of=self.is_type_of,