prompt: You will be provided with a partial code base and an issue statement explaining a problem to resolve.
  <issue>
  Inconsistent static analysis via pyright
  ```python
  x = [1, 2, 3]
  make_config(a=[1, 2, 3])
  make_config(a=x)  # pyright marks this as invalid based on our annotations
  ```
  
  This seems like a pyright issue, but we might consider revising annotations to accommodate
  
  </issue>
  <code>
  [start of src/hydra_zen/typing/_implementations.py]
  1 # Copyright (c) 2021 Massachusetts Institute of Technology
  2 # SPDX-License-Identifier: MIT
  3 
  4 from dataclasses import Field
  5 from enum import Enum
  6 from pathlib import Path
  7 from typing import (
  8     Any,
  9     Callable,
  10     Counter,
  11     Deque,
  12     Dict,
  13     FrozenSet,
  14     Generic,
  15     List,
  16     NewType,
  17     Set,
  18     Tuple,
  19     TypeVar,
  20     Union,
  21 )
  22 
  23 from omegaconf import DictConfig, ListConfig
  24 from typing_extensions import Protocol, runtime_checkable
  25 
  26 __all__ = [
  27     "Just",
  28     "Builds",
  29     "PartialBuilds",
  30     "Partial",
  31     "Importable",
  32     "SupportedPrimitive",
  33 ]
  34 
  35 
  36 _T = TypeVar("_T", covariant=True)
  37 
  38 
  39 class Partial(Generic[_T]):
  40     func: Callable[..., _T]
  41     args: Tuple[Any, ...]
  42     keywords: Dict[str, Any]
  43 
  44     def __init__(
  45         self, func: Callable[..., _T], *args: Any, **kwargs: Any
  46     ) -> None:  # pragma: no cover
  47         ...
  48 
  49     def __call__(self, *args: Any, **kwargs: Any) -> _T:  # pragma: no cover
  50         ...
  51 
  52 
  53 InterpStr = NewType("InterpStr", str)
  54 
  55 Importable = TypeVar("Importable")
  56 
  57 
  58 class _DataClass(Protocol):  # pragma: no cover
  59     # doesn't provide __init__, __getattribute__, etc.
  60     __dataclass_fields__: Dict[str, Field]
  61 
  62 
  63 class DataClass(_DataClass, Protocol):  # pragma: no cover
  64     def __init__(self, *args, **kwargs) -> None:
  65         ...
  66 
  67     def __getattribute__(self, name: str) -> Any:
  68         ...
  69 
  70     def __setattr__(self, name: str, value: Any) -> None:
  71         ...
  72 
  73 
  74 @runtime_checkable
  75 class Builds(DataClass, Protocol[_T]):  # pragma: no cover
  76 
  77     _target_: str
  78 
  79 
  80 @runtime_checkable
  81 class Just(Builds, Protocol[_T]):  # pragma: no cover
  82     path: str  # interpolated string for importing obj
  83     _target_: str = "hydra_zen.funcs.get_obj"
  84 
  85 
  86 @runtime_checkable
  87 class PartialBuilds(Builds, Protocol[_T]):  # pragma: no cover
  88     _target_: str = "hydra_zen.funcs.zen_processing"
  89     _zen_target: str
  90     _zen_partial: bool = True
  91 
  92 
  93 @runtime_checkable
  94 class HasTarget(Protocol):  # pragma: no cover
  95     _target_: str
  96 
  97 
  98 @runtime_checkable
  99 class HasPartialTarget(Protocol):  # pragma: no cover
  100     _zen_partial: bool = True
  101 
  102 
  103 _HydraPrimitive = Union[
  104     bool,
  105     None,
  106     int,
  107     float,
  108     str,
  109 ]
  110 
  111 _SupportedPrimitive = Union[
  112     _HydraPrimitive,
  113     ListConfig,
  114     DictConfig,
  115     type,
  116     Callable,
  117     Enum,
  118     _DataClass,
  119     complex,
  120     Path,
  121     range,
  122 ]
  123 
  124 SupportedPrimitive = Union[
  125     _SupportedPrimitive,
  126     Dict[_HydraPrimitive, "SupportedPrimitive"],
  127     Counter[_HydraPrimitive],
  128     Set["SupportedPrimitive"],
  129     FrozenSet["SupportedPrimitive"],
  130     Deque["SupportedPrimitive"],
  131     List["SupportedPrimitive"],
  132     Tuple["SupportedPrimitive", ...],
  133 ]
  134
  [end of src/hydra_zen/typing/_implementations.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/src/hydra_zen/typing/_implementations.py b/src/hydra_zen/typing/_implementations.py
  --- a/src/hydra_zen/typing/_implementations.py
  +++ b/src/hydra_zen/typing/_implementations.py
  @@ -7,21 +7,19 @@
   from typing import (
       Any,
       Callable,
  -    Counter,
  -    Deque,
       Dict,
       FrozenSet,
       Generic,
  -    List,
  +    Mapping,
       NewType,
  -    Set,
  +    Sequence,
       Tuple,
       TypeVar,
       Union,
   )
   
   from omegaconf import DictConfig, ListConfig
  -from typing_extensions import Protocol, runtime_checkable
  +from typing_extensions import Protocol, TypedDict, runtime_checkable
   
   __all__ = [
       "Just",
  @@ -33,6 +31,10 @@
   ]
   
   
  +class EmptyDict(TypedDict):
  +    pass
  +
  +
   _T = TypeVar("_T", covariant=True)
   
   
  @@ -119,15 +121,21 @@
       complex,
       Path,
       range,
  +    set,
  +    EmptyDict,  # not covered by Mapping[..., ...]
   ]
   
   SupportedPrimitive = Union[
       _SupportedPrimitive,
  -    Dict[_HydraPrimitive, "SupportedPrimitive"],
  -    Counter[_HydraPrimitive],
  -    Set["SupportedPrimitive"],
       FrozenSet["SupportedPrimitive"],
  -    Deque["SupportedPrimitive"],
  -    List["SupportedPrimitive"],
  -    Tuple["SupportedPrimitive", ...],
  +    # Even thought this is redundant with Sequence, it seems to
  +    # be needed for pyright to do proper checking of tuple contents
  +    Tuple["SupportedPrimitive"],
  +    # Mutable generic containers need to be invariant, so
  +    # we have to settle for Sequence/Mapping. While this
  +    # is overly permissive in terms of sequence-type, it
  +    # at least affords quality checking of sequence content
  +    Sequence["SupportedPrimitive"],
  +    # Mapping is covariant only in value
  +    Mapping[Any, "SupportedPrimitive"],
   ]
  
verification_info: {"golden_diff": "diff --git a/src/hydra_zen/typing/_implementations.py b/src/hydra_zen/typing/_implementations.py\n--- a/src/hydra_zen/typing/_implementations.py\n+++ b/src/hydra_zen/typing/_implementations.py\n@@ -7,21 +7,19 @@\n from typing import (\n     Any,\n     Callable,\n-    Counter,\n-    Deque,\n     Dict,\n     FrozenSet,\n     Generic,\n-    List,\n+    Mapping,\n     NewType,\n-    Set,\n+    Sequence,\n     Tuple,\n     TypeVar,\n     Union,\n )\n \n from omegaconf import DictConfig, ListConfig\n-from typing_extensions import Protocol, runtime_checkable\n+from typing_extensions import Protocol, TypedDict, runtime_checkable\n \n __all__ = [\n     \"Just\",\n@@ -33,6 +31,10 @@\n ]\n \n \n+class EmptyDict(TypedDict):\n+    pass\n+\n+\n _T = TypeVar(\"_T\", covariant=True)\n \n \n@@ -119,15 +121,21 @@\n     complex,\n     Path,\n     range,\n+    set,\n+    EmptyDict,  # not covered by Mapping[..., ...]\n ]\n \n SupportedPrimitive = Union[\n     _SupportedPrimitive,\n-    Dict[_HydraPrimitive, \"SupportedPrimitive\"],\n-    Counter[_HydraPrimitive],\n-    Set[\"SupportedPrimitive\"],\n     FrozenSet[\"SupportedPrimitive\"],\n-    Deque[\"SupportedPrimitive\"],\n-    List[\"SupportedPrimitive\"],\n-    Tuple[\"SupportedPrimitive\", ...],\n+    # Even thought this is redundant with Sequence, it seems to\n+    # be needed for pyright to do proper checking of tuple contents\n+    Tuple[\"SupportedPrimitive\"],\n+    # Mutable generic containers need to be invariant, so\n+    # we have to settle for Sequence/Mapping. While this\n+    # is overly permissive in terms of sequence-type, it\n+    # at least affords quality checking of sequence content\n+    Sequence[\"SupportedPrimitive\"],\n+    # Mapping is covariant only in value\n+    Mapping[Any, \"SupportedPrimitive\"],\n ]\n", "issue": "Inconsistent static analysis via pyright\n```python\r\nx = [1, 2, 3]\r\nmake_config(a=[1, 2, 3])\r\nmake_config(a=x)  # pyright marks this as invalid based on our annotations\r\n```\r\n\r\nThis seems like a pyright issue, but we might consider revising annotations to accommodate\n", "before_files": [{"content": "# Copyright (c) 2021 Massachusetts Institute of Technology\n# SPDX-License-Identifier: MIT\n\nfrom dataclasses import Field\nfrom enum import Enum\nfrom pathlib import Path\nfrom typing import (\n    Any,\n    Callable,\n    Counter,\n    Deque,\n    Dict,\n    FrozenSet,\n    Generic,\n    List,\n    NewType,\n    Set,\n    Tuple,\n    TypeVar,\n    Union,\n)\n\nfrom omegaconf import DictConfig, ListConfig\nfrom typing_extensions import Protocol, runtime_checkable\n\n__all__ = [\n    \"Just\",\n    \"Builds\",\n    \"PartialBuilds\",\n    \"Partial\",\n    \"Importable\",\n    \"SupportedPrimitive\",\n]\n\n\n_T = TypeVar(\"_T\", covariant=True)\n\n\nclass Partial(Generic[_T]):\n    func: Callable[..., _T]\n    args: Tuple[Any, ...]\n    keywords: Dict[str, Any]\n\n    def __init__(\n        self, func: Callable[..., _T], *args: Any, **kwargs: Any\n    ) -> None:  # pragma: no cover\n        ...\n\n    def __call__(self, *args: Any, **kwargs: Any) -> _T:  # pragma: no cover\n        ...\n\n\nInterpStr = NewType(\"InterpStr\", str)\n\nImportable = TypeVar(\"Importable\")\n\n\nclass _DataClass(Protocol):  # pragma: no cover\n    # doesn't provide __init__, __getattribute__, etc.\n    __dataclass_fields__: Dict[str, Field]\n\n\nclass DataClass(_DataClass, Protocol):  # pragma: no cover\n    def __init__(self, *args, **kwargs) -> None:\n        ...\n\n    def __getattribute__(self, name: str) -> Any:\n        ...\n\n    def __setattr__(self, name: str, value: Any) -> None:\n        ...\n\n\n@runtime_checkable\nclass Builds(DataClass, Protocol[_T]):  # pragma: no cover\n\n    _target_: str\n\n\n@runtime_checkable\nclass Just(Builds, Protocol[_T]):  # pragma: no cover\n    path: str  # interpolated string for importing obj\n    _target_: str = \"hydra_zen.funcs.get_obj\"\n\n\n@runtime_checkable\nclass PartialBuilds(Builds, Protocol[_T]):  # pragma: no cover\n    _target_: str = \"hydra_zen.funcs.zen_processing\"\n    _zen_target: str\n    _zen_partial: bool = True\n\n\n@runtime_checkable\nclass HasTarget(Protocol):  # pragma: no cover\n    _target_: str\n\n\n@runtime_checkable\nclass HasPartialTarget(Protocol):  # pragma: no cover\n    _zen_partial: bool = True\n\n\n_HydraPrimitive = Union[\n    bool,\n    None,\n    int,\n    float,\n    str,\n]\n\n_SupportedPrimitive = Union[\n    _HydraPrimitive,\n    ListConfig,\n    DictConfig,\n    type,\n    Callable,\n    Enum,\n    _DataClass,\n    complex,\n    Path,\n    range,\n]\n\nSupportedPrimitive = Union[\n    _SupportedPrimitive,\n    Dict[_HydraPrimitive, \"SupportedPrimitive\"],\n    Counter[_HydraPrimitive],\n    Set[\"SupportedPrimitive\"],\n    FrozenSet[\"SupportedPrimitive\"],\n    Deque[\"SupportedPrimitive\"],\n    List[\"SupportedPrimitive\"],\n    Tuple[\"SupportedPrimitive\", ...],\n]\n", "path": "src/hydra_zen/typing/_implementations.py"}]}