We are currently solving the following issue within our repository. Here is the issue text:
--- BEGIN ISSUE ---
Missing attrs in LazyFrames: dtype, shape
This is my own fault.. I managed to push the wrong branch in #1906 

--- END ISSUE ---

Below are some code segments, each from a relevant file. One or more of these files may contain bugs.
--- BEGIN FILES ---
Path: `gym/wrappers/frame_stack.py`
Content:
```
1 from collections import deque
2 import numpy as np
3 
4 from gym.spaces import Box
5 from gym import Wrapper
6 
7 
8 class LazyFrames(object):
9     r"""Ensures common frames are only stored once to optimize memory use.
10 
11     To further reduce the memory use, it is optionally to turn on lz4 to
12     compress the observations.
13 
14     .. note::
15 
16         This object should only be converted to numpy array just before forward pass.
17 
18     Args:
19         lz4_compress (bool): use lz4 to compress the frames internally
20 
21     """
22     __slots__ = ('frame_shape', 'dtype', 'shape', 'lz4_compress', '_frames')
23 
24     def __init__(self, frames, lz4_compress=False):
25         if lz4_compress:
26             from lz4.block import compress
27             self.frame_shape = tuple(frames[0].shape)
28             self.dtype = frames[0].dtype
29             self.shape = (len(frames),) + self.frame_shape
30             frames = [compress(frame) for frame in frames]
31         self._frames = frames
32         self.lz4_compress = lz4_compress
33 
34     def __array__(self, dtype=None):
35         arr = self[:]
36         if dtype is not None:
37             return arr.astype(dtype)
38         return arr
39 
40     def __len__(self):
41         return self.shape[0]
42 
43     def __getitem__(self, int_or_slice):
44         if isinstance(int_or_slice, int):
45             return self._check_decompress(self._frames[int_or_slice])  # single frame
46         return np.stack([self._check_decompress(f) for f in self._frames[int_or_slice]], axis=0)
47 
48     def __eq__(self, other):
49         return self.__array__() == other
50 
51     def _check_decompress(self, frame):
52         if self.lz4_compress:
53             from lz4.block import decompress
54             return np.frombuffer(decompress(frame), dtype=self.dtype).reshape(self.frame_shape)
55         return frame
56 
57 
58 class FrameStack(Wrapper):
59     r"""Observation wrapper that stacks the observations in a rolling manner.
60 
61     For example, if the number of stacks is 4, then the returned observation contains
62     the most recent 4 observations. For environment 'Pendulum-v0', the original observation
63     is an array with shape [3], so if we stack 4 observations, the processed observation
64     has shape [4, 3].
65 
66     .. note::
67 
68         To be memory efficient, the stacked observations are wrapped by :class:`LazyFrame`.
69 
70     .. note::
71 
72         The observation space must be `Box` type. If one uses `Dict`
73         as observation space, it should apply `FlattenDictWrapper` at first.
74 
75     Example::
76 
77         >>> import gym
78         >>> env = gym.make('PongNoFrameskip-v0')
79         >>> env = FrameStack(env, 4)
80         >>> env.observation_space
81         Box(4, 210, 160, 3)
82 
83     Args:
84         env (Env): environment object
85         num_stack (int): number of stacks
86         lz4_compress (bool): use lz4 to compress the frames internally
87 
88     """
89     def __init__(self, env, num_stack, lz4_compress=False):
90         super(FrameStack, self).__init__(env)
91         self.num_stack = num_stack
92         self.lz4_compress = lz4_compress
93 
94         self.frames = deque(maxlen=num_stack)
95 
96         low = np.repeat(self.observation_space.low[np.newaxis, ...], num_stack, axis=0)
97         high = np.repeat(self.observation_space.high[np.newaxis, ...], num_stack, axis=0)
98         self.observation_space = Box(low=low, high=high, dtype=self.observation_space.dtype)
99 
100     def _get_observation(self):
101         assert len(self.frames) == self.num_stack, (len(self.frames), self.num_stack)
102         return LazyFrames(list(self.frames), self.lz4_compress)
103 
104     def step(self, action):
105         observation, reward, done, info = self.env.step(action)
106         self.frames.append(observation)
107         return self._get_observation(), reward, done, info
108 
109     def reset(self, **kwargs):
110         observation = self.env.reset(**kwargs)
111         [self.frames.append(observation) for _ in range(self.num_stack)]
112         return self._get_observation()
113
```
--- END FILES ---

Please first localize the bug based on the issue statement, and then generate a patch according to the `git diff` format fenced by three backticks.

Here is an example:

```diff
diff --git a/examples/server_async.py b/examples/server_async.py
--- a/examples/server_async.py
+++ b/examples/server_async.py
@@ -313,4 +313,4 @@
 
 
 if __name__ == "__main__":
-    asyncio.run(run_async_server("."), debug=True)
+    asyncio.run(run_async_server(), debug=True)
diff --git a/examples/server_sync.py b/examples/server_sync.py
--- a/examples/server_sync.py
+++ b/examples/server_sync.py
@@ -313,5 +313,5 @@
 
 
 if __name__ == "__main__":
-    server = run_sync_server(".")
+    server = run_sync_server()
     server.shutdown()

```

diff --git a/gym/wrappers/frame_stack.py b/gym/wrappers/frame_stack.py
--- a/gym/wrappers/frame_stack.py
+++ b/gym/wrappers/frame_stack.py
@@ -22,11 +22,11 @@
     __slots__ = ('frame_shape', 'dtype', 'shape', 'lz4_compress', '_frames')
 
     def __init__(self, frames, lz4_compress=False):
+        self.frame_shape = tuple(frames[0].shape)
+        self.shape = (len(frames),) + self.frame_shape
+        self.dtype = frames[0].dtype
         if lz4_compress:
             from lz4.block import compress
-            self.frame_shape = tuple(frames[0].shape)
-            self.dtype = frames[0].dtype
-            self.shape = (len(frames),) + self.frame_shape
             frames = [compress(frame) for frame in frames]
         self._frames = frames
         self.lz4_compress = lz4_compress

{"golden_diff": "diff --git a/gym/wrappers/frame_stack.py b/gym/wrappers/frame_stack.py\n--- a/gym/wrappers/frame_stack.py\n+++ b/gym/wrappers/frame_stack.py\n@@ -22,11 +22,11 @@\n     __slots__ = ('frame_shape', 'dtype', 'shape', 'lz4_compress', '_frames')\n \n     def __init__(self, frames, lz4_compress=False):\n+        self.frame_shape = tuple(frames[0].shape)\n+        self.shape = (len(frames),) + self.frame_shape\n+        self.dtype = frames[0].dtype\n         if lz4_compress:\n             from lz4.block import compress\n-            self.frame_shape = tuple(frames[0].shape)\n-            self.dtype = frames[0].dtype\n-            self.shape = (len(frames),) + self.frame_shape\n             frames = [compress(frame) for frame in frames]\n         self._frames = frames\n         self.lz4_compress = lz4_compress\n", "issue": "Missing attrs in LazyFrames: dtype, shape\nThis is my own fault.. I managed to push the wrong branch in #1906 \n", "before_files": [{"content": "from collections import deque\nimport numpy as np\n\nfrom gym.spaces import Box\nfrom gym import Wrapper\n\n\nclass LazyFrames(object):\n    r\"\"\"Ensures common frames are only stored once to optimize memory use.\n\n    To further reduce the memory use, it is optionally to turn on lz4 to\n    compress the observations.\n\n    .. note::\n\n        This object should only be converted to numpy array just before forward pass.\n\n    Args:\n        lz4_compress (bool): use lz4 to compress the frames internally\n\n    \"\"\"\n    __slots__ = ('frame_shape', 'dtype', 'shape', 'lz4_compress', '_frames')\n\n    def __init__(self, frames, lz4_compress=False):\n        if lz4_compress:\n            from lz4.block import compress\n            self.frame_shape = tuple(frames[0].shape)\n            self.dtype = frames[0].dtype\n            self.shape = (len(frames),) + self.frame_shape\n            frames = [compress(frame) for frame in frames]\n        self._frames = frames\n        self.lz4_compress = lz4_compress\n\n    def __array__(self, dtype=None):\n        arr = self[:]\n        if dtype is not None:\n            return arr.astype(dtype)\n        return arr\n\n    def __len__(self):\n        return self.shape[0]\n\n    def __getitem__(self, int_or_slice):\n        if isinstance(int_or_slice, int):\n            return self._check_decompress(self._frames[int_or_slice])  # single frame\n        return np.stack([self._check_decompress(f) for f in self._frames[int_or_slice]], axis=0)\n\n    def __eq__(self, other):\n        return self.__array__() == other\n\n    def _check_decompress(self, frame):\n        if self.lz4_compress:\n            from lz4.block import decompress\n            return np.frombuffer(decompress(frame), dtype=self.dtype).reshape(self.frame_shape)\n        return frame\n\n\nclass FrameStack(Wrapper):\n    r\"\"\"Observation wrapper that stacks the observations in a rolling manner.\n\n    For example, if the number of stacks is 4, then the returned observation contains\n    the most recent 4 observations. For environment 'Pendulum-v0', the original observation\n    is an array with shape [3], so if we stack 4 observations, the processed observation\n    has shape [4, 3].\n\n    .. note::\n\n        To be memory efficient, the stacked observations are wrapped by :class:`LazyFrame`.\n\n    .. note::\n\n        The observation space must be `Box` type. If one uses `Dict`\n        as observation space, it should apply `FlattenDictWrapper` at first.\n\n    Example::\n\n        >>> import gym\n        >>> env = gym.make('PongNoFrameskip-v0')\n        >>> env = FrameStack(env, 4)\n        >>> env.observation_space\n        Box(4, 210, 160, 3)\n\n    Args:\n        env (Env): environment object\n        num_stack (int): number of stacks\n        lz4_compress (bool): use lz4 to compress the frames internally\n\n    \"\"\"\n    def __init__(self, env, num_stack, lz4_compress=False):\n        super(FrameStack, self).__init__(env)\n        self.num_stack = num_stack\n        self.lz4_compress = lz4_compress\n\n        self.frames = deque(maxlen=num_stack)\n\n        low = np.repeat(self.observation_space.low[np.newaxis, ...], num_stack, axis=0)\n        high = np.repeat(self.observation_space.high[np.newaxis, ...], num_stack, axis=0)\n        self.observation_space = Box(low=low, high=high, dtype=self.observation_space.dtype)\n\n    def _get_observation(self):\n        assert len(self.frames) == self.num_stack, (len(self.frames), self.num_stack)\n        return LazyFrames(list(self.frames), self.lz4_compress)\n\n    def step(self, action):\n        observation, reward, done, info = self.env.step(action)\n        self.frames.append(observation)\n        return self._get_observation(), reward, done, info\n\n    def reset(self, **kwargs):\n        observation = self.env.reset(**kwargs)\n        [self.frames.append(observation) for _ in range(self.num_stack)]\n        return self._get_observation()\n", "path": "gym/wrappers/frame_stack.py"}], "after_files": [{"content": "from collections import deque\nimport numpy as np\n\nfrom gym.spaces import Box\nfrom gym import Wrapper\n\n\nclass LazyFrames(object):\n    r\"\"\"Ensures common frames are only stored once to optimize memory use.\n\n    To further reduce the memory use, it is optionally to turn on lz4 to\n    compress the observations.\n\n    .. note::\n\n        This object should only be converted to numpy array just before forward pass.\n\n    Args:\n        lz4_compress (bool): use lz4 to compress the frames internally\n\n    \"\"\"\n    __slots__ = ('frame_shape', 'dtype', 'shape', 'lz4_compress', '_frames')\n\n    def __init__(self, frames, lz4_compress=False):\n        self.frame_shape = tuple(frames[0].shape)\n        self.shape = (len(frames),) + self.frame_shape\n        self.dtype = frames[0].dtype\n        if lz4_compress:\n            from lz4.block import compress\n            frames = [compress(frame) for frame in frames]\n        self._frames = frames\n        self.lz4_compress = lz4_compress\n\n    def __array__(self, dtype=None):\n        arr = self[:]\n        if dtype is not None:\n            return arr.astype(dtype)\n        return arr\n\n    def __len__(self):\n        return self.shape[0]\n\n    def __getitem__(self, int_or_slice):\n        if isinstance(int_or_slice, int):\n            return self._check_decompress(self._frames[int_or_slice])  # single frame\n        return np.stack([self._check_decompress(f) for f in self._frames[int_or_slice]], axis=0)\n\n    def __eq__(self, other):\n        return self.__array__() == other\n\n    def _check_decompress(self, frame):\n        if self.lz4_compress:\n            from lz4.block import decompress\n            return np.frombuffer(decompress(frame), dtype=self.dtype).reshape(self.frame_shape)\n        return frame\n\n\nclass FrameStack(Wrapper):\n    r\"\"\"Observation wrapper that stacks the observations in a rolling manner.\n\n    For example, if the number of stacks is 4, then the returned observation contains\n    the most recent 4 observations. For environment 'Pendulum-v0', the original observation\n    is an array with shape [3], so if we stack 4 observations, the processed observation\n    has shape [4, 3].\n\n    .. note::\n\n        To be memory efficient, the stacked observations are wrapped by :class:`LazyFrame`.\n\n    .. note::\n\n        The observation space must be `Box` type. If one uses `Dict`\n        as observation space, it should apply `FlattenDictWrapper` at first.\n\n    Example::\n\n        >>> import gym\n        >>> env = gym.make('PongNoFrameskip-v0')\n        >>> env = FrameStack(env, 4)\n        >>> env.observation_space\n        Box(4, 210, 160, 3)\n\n    Args:\n        env (Env): environment object\n        num_stack (int): number of stacks\n        lz4_compress (bool): use lz4 to compress the frames internally\n\n    \"\"\"\n    def __init__(self, env, num_stack, lz4_compress=False):\n        super(FrameStack, self).__init__(env)\n        self.num_stack = num_stack\n        self.lz4_compress = lz4_compress\n\n        self.frames = deque(maxlen=num_stack)\n\n        low = np.repeat(self.observation_space.low[np.newaxis, ...], num_stack, axis=0)\n        high = np.repeat(self.observation_space.high[np.newaxis, ...], num_stack, axis=0)\n        self.observation_space = Box(low=low, high=high, dtype=self.observation_space.dtype)\n\n    def _get_observation(self):\n        assert len(self.frames) == self.num_stack, (len(self.frames), self.num_stack)\n        return LazyFrames(list(self.frames), self.lz4_compress)\n\n    def step(self, action):\n        observation, reward, done, info = self.env.step(action)\n        self.frames.append(observation)\n        return self._get_observation(), reward, done, info\n\n    def reset(self, **kwargs):\n        observation = self.env.reset(**kwargs)\n        [self.frames.append(observation) for _ in range(self.num_stack)]\n        return self._get_observation()\n", "path": "gym/wrappers/frame_stack.py"}]}