prompt: You will be provided with a partial code base and an issue statement explaining a problem to resolve.
  <issue>
  `merge_type` `types` type hint
  https://github.com/strawberry-graphql/strawberry/blob/main/strawberry/tools/merge_types.py#L9
  
  The current `Tuple[Type]` produces:
  ```
  *.py:15:5: error: Argument 2 to "merge_types" has incompatible type "Tuple[Type[QueryA], Type[QueryB], Type[QueryC]]"; expected "Tuple[Type[Any]]"  [arg-type]
  ```
  
  According to [mypy](https://mypy.readthedocs.io/en/stable/kinds_of_types.html#tuple-types), we should either change it to `Tuple[Type, ...]` or follow mypy's suggestion and go with a generic `Sequence`.
  
  
  
  </issue>
  <code>
  [start of strawberry/tools/merge_types.py]
  1 import warnings
  2 from collections import Counter
  3 from itertools import chain
  4 from typing import Tuple, Type
  5 
  6 import strawberry
  7 
  8 
  9 def merge_types(name: str, types: Tuple[Type]) -> Type:
  10     """Merge multiple Strawberry types into one
  11 
  12     For example, given two queries `A` and `B`, one can merge them into a
  13     super type as follows:
  14 
  15         merge_types("SuperQuery", (B, A))
  16 
  17     This is essentially the same as:
  18 
  19         class SuperQuery(B, A):
  20             ...
  21     """
  22 
  23     if not types:
  24         raise ValueError("Can't merge types if none are supplied")
  25 
  26     fields = chain(*(t._type_definition.fields for t in types))
  27     counter = Counter(f.name for f in fields)
  28     dupes = [f for f, c in counter.most_common() if c > 1]
  29     if dupes:
  30         warnings.warn("{} has overridden fields: {}".format(name, ", ".join(dupes)))
  31 
  32     return strawberry.type(type(name, types, {}))
  33
  [end of strawberry/tools/merge_types.py]
  </code>
  
  I need you to solve this issue by generating a single patch file that I can apply directly to this repository using git apply. Please respond with a single patch file in the following format.
  <patch>
  diff --git a/file.py b/file.py
  --- a/file.py
  +++ b/file.py
  @@ -1,27 +1,35 @@
   def euclidean(a, b):
  -    while b:
  -        a, b = b, a % b
  -    return a
  +    if b == 0:
  +        return a
  +    return euclidean(b, a % b)
   
   
   def bresenham(x0, y0, x1, y1):
       points = []
       dx = abs(x1 - x0)
       dy = abs(y1 - y0)
  -    sx = 1 if x0 < x1 else -1
  -    sy = 1 if y0 < y1 else -1
  -    err = dx - dy
  +    x, y = x0, y0
  +    sx = -1 if x0 > x1 else 1
  +    sy = -1 if y0 > y1 else 1
   
  -    while True:
  -        points.append((x0, y0))
  -        if x0 == x1 and y0 == y1:
  -            break
  -        e2 = 2 * err
  -        if e2 > -dy:
  -            err -= dy
  -            x0 += sx
  -        if e2 < dx:
  -            err += dx
  -            y0 += sy
  +    if dx > dy:
  +        err = dx / 2.0
  +        while x != x1:
  +            points.append((x, y))
  +            err -= dy
  +            if err < 0:
  +                y += sy
  +                err += dx
  +            x += sx
  +    else:
  +        err = dy / 2.0
  +        while y != y1:
  +            points.append((x, y))
  +            err -= dx
  +            if err < 0:
  +                x += sx
  +                err += dy
  +            y += sy
  +
  +    points.append((x, y))
       return points
  
  </patch>
golden_diff: diff --git a/strawberry/tools/merge_types.py b/strawberry/tools/merge_types.py
  --- a/strawberry/tools/merge_types.py
  +++ b/strawberry/tools/merge_types.py
  @@ -1,12 +1,12 @@
   import warnings
   from collections import Counter
   from itertools import chain
  -from typing import Tuple, Type
  +from typing import Tuple
   
   import strawberry
   
   
  -def merge_types(name: str, types: Tuple[Type]) -> Type:
  +def merge_types(name: str, types: Tuple[type, ...]) -> type:
       """Merge multiple Strawberry types into one
   
       For example, given two queries `A` and `B`, one can merge them into a
  @@ -23,7 +23,9 @@
       if not types:
           raise ValueError("Can't merge types if none are supplied")
   
  -    fields = chain(*(t._type_definition.fields for t in types))
  +    fields = chain(
  +        *(t._type_definition.fields for t in types)  # type: ignore[attr-defined]
  +    )
       counter = Counter(f.name for f in fields)
       dupes = [f for f, c in counter.most_common() if c > 1]
       if dupes:
  
verification_info: {"golden_diff": "diff --git a/strawberry/tools/merge_types.py b/strawberry/tools/merge_types.py\n--- a/strawberry/tools/merge_types.py\n+++ b/strawberry/tools/merge_types.py\n@@ -1,12 +1,12 @@\n import warnings\n from collections import Counter\n from itertools import chain\n-from typing import Tuple, Type\n+from typing import Tuple\n \n import strawberry\n \n \n-def merge_types(name: str, types: Tuple[Type]) -> Type:\n+def merge_types(name: str, types: Tuple[type, ...]) -> type:\n     \"\"\"Merge multiple Strawberry types into one\n \n     For example, given two queries `A` and `B`, one can merge them into a\n@@ -23,7 +23,9 @@\n     if not types:\n         raise ValueError(\"Can't merge types if none are supplied\")\n \n-    fields = chain(*(t._type_definition.fields for t in types))\n+    fields = chain(\n+        *(t._type_definition.fields for t in types)  # type: ignore[attr-defined]\n+    )\n     counter = Counter(f.name for f in fields)\n     dupes = [f for f, c in counter.most_common() if c > 1]\n     if dupes:\n", "issue": "`merge_type` `types` type hint\nhttps://github.com/strawberry-graphql/strawberry/blob/main/strawberry/tools/merge_types.py#L9\r\n\r\nThe current `Tuple[Type]` produces:\r\n```\r\n*.py:15:5: error: Argument 2 to \"merge_types\" has incompatible type \"Tuple[Type[QueryA], Type[QueryB], Type[QueryC]]\"; expected \"Tuple[Type[Any]]\"  [arg-type]\r\n```\r\n\r\nAccording to [mypy](https://mypy.readthedocs.io/en/stable/kinds_of_types.html#tuple-types), we should either change it to `Tuple[Type, ...]` or follow mypy's suggestion and go with a generic `Sequence`.\r\n\r\n\n", "before_files": [{"content": "import warnings\nfrom collections import Counter\nfrom itertools import chain\nfrom typing import Tuple, Type\n\nimport strawberry\n\n\ndef merge_types(name: str, types: Tuple[Type]) -> Type:\n    \"\"\"Merge multiple Strawberry types into one\n\n    For example, given two queries `A` and `B`, one can merge them into a\n    super type as follows:\n\n        merge_types(\"SuperQuery\", (B, A))\n\n    This is essentially the same as:\n\n        class SuperQuery(B, A):\n            ...\n    \"\"\"\n\n    if not types:\n        raise ValueError(\"Can't merge types if none are supplied\")\n\n    fields = chain(*(t._type_definition.fields for t in types))\n    counter = Counter(f.name for f in fields)\n    dupes = [f for f, c in counter.most_common() if c > 1]\n    if dupes:\n        warnings.warn(\"{} has overridden fields: {}\".format(name, \", \".join(dupes)))\n\n    return strawberry.type(type(name, types, {}))\n", "path": "strawberry/tools/merge_types.py"}]}