Can't run flappy bird envrionment with gymnasium

[IAMHAADICOOL]

Question

I am installing pygame and gym_ple from the following two commands:
!pip install git+https://github.com/GrupoTuring/PyGame-Learning-Environment
!pip install git+https://github.com/lusob/gym-ple
I am doing the following imports (they are part of a bigger project)
import copy
import torch
import random
import gym
import gym_ple
import matplotlib

import numpy as np
import torch.nn.functional as F

import matplotlib.pyplot as plt
import matplotlib.animation as animation

from collections import deque, namedtuple
from IPython.display import HTML
from base64 import b64encode

from torch import nn
from torch.utils.data import DataLoader
from torch.utils.data.dataset import IterableDataset
from torch.optim import AdamW

from pytorch_lightning import LightningModule, Trainer

from gym.wrappers import TransformObservation

device = 'cuda:0' if torch.cuda.is_available() else 'cpu'
num_gpus = torch.cuda.device_count()

Then I run the following lines of code:
env = gym_ple.make("FlappyBird-v0")
env.step(env.action_space.sample())

And I get the following error:

NotImplementedError Traceback (most recent call last)
Cell In[25], line 1
----> 1 env.step(env.action_space.sample())

File d:\anaconda3\Lib\site-packages\gym\wrappers\time_limit.py:17, in TimeLimit.step(self, action)
16 def step(self, action):
---> 17 observation, reward, done, info = self.env.step(action)
18 self._elapsed_steps += 1
19 if self._elapsed_steps >= self._max_episode_steps:

File d:\anaconda3\Lib\site-packages\gym\wrappers\order_enforcing.py:13, in OrderEnforcing.step(self, action)
11 def step(self, action):
12 assert self._has_reset, "Cannot call env.step() before calling reset()"
---> 13 observation, reward, done, info = self.env.step(action)
14 return observation, reward, done, info

File d:\anaconda3\Lib\site-packages\gym\core.py:80, in Env.step(self, action)
63 @AbstractMethod
64 def step(self, action: ActType) -> Tuple[ObsType, float, bool, dict]:
65 """Run one timestep of the environment's dynamics. When end of
66 episode is reached, you are responsible for calling reset()
67 to reset this environment's state.
(...)
78 info (dict): contains auxiliary diagnostic information (helpful for debugging, logging, and sometimes learning)
79 """
---> 80 raise NotImplementedError

NotImplementedError:

I went into the site-packages directory inside my anaconda3 folder and I found the ple and gym_ple folder, and also, the file for FlappyBird game inside the ple folder. Please help me understand what is wrong

And I also intend to use the following wrappers for normalization:
class RunningMeanStd:
# https://en.wikipedia.org/wiki/Algorithms_for_calculating_variance#Parallel_algorithm
def init(self, epsilon=1e-4, shape=()):
self.mean = np.zeros(shape, "float64")
self.var = np.ones(shape, "float64")
self.count = epsilon

def update(self, x):
    batch_mean = np.mean(x, axis=0)
    batch_var = np.var(x, axis=0)
    batch_count = x.shape[0]
    self.update_from_moments(batch_mean, batch_var, batch_count)

def update_from_moments(self, batch_mean, batch_var, batch_count):
    self.mean, self.var, self.count = update_mean_var_count_from_moments(
        self.mean, self.var, self.count, batch_mean, batch_var, batch_count
    )

def update_mean_var_count_from_moments(
mean, var, count, batch_mean, batch_var, batch_count
):
delta = batch_mean - mean
tot_count = count + batch_count

new_mean = mean + delta * batch_count / tot_count
m_a = var * count
m_b = batch_var * batch_count
M2 = m_a + m_b + np.square(delta) * count * batch_count / tot_count
new_var = M2 / tot_count
new_count = tot_count

return new_mean, new_var, new_count

class NormalizeObservation(gym.core.Wrapper):
def init(
self,
env,
epsilon=1e-8,
):
super().init(env)
self.num_envs = getattr(env, "num_envs", 1)
self.is_vector_env = getattr(env, "is_vector_env", False)
if self.is_vector_env:
self.obs_rms = RunningMeanStd(shape=self.single_observation_space.shape)
else:
self.obs_rms = RunningMeanStd(shape=self.observation_space.shape)
self.epsilon = epsilon

def step(self, action):
    obs, rews, dones, infos = self.env.step(action)
    if self.is_vector_env:
        obs = self.normalize(obs)
    else:
        obs = self.normalize(np.array([obs]))[0]
    return obs, rews, dones, infos

def reset(self, **kwargs):
    return_info = kwargs.get("return_info", False)
    if return_info:
        obs, info = self.env.reset(**kwargs)
    else:
        obs = self.env.reset(**kwargs)
    if self.is_vector_env:
        obs = self.normalize(obs)
    else:
        obs = self.normalize(np.array([obs]))[0]
    if not return_info:
        return obs
    else:
        return obs, info

def normalize(self, obs):
    self.obs_rms.update(obs)
    return (obs - self.obs_rms.mean) / np.sqrt(self.obs_rms.var + self.epsilon)

class NormalizeReward(gym.core.Wrapper):
def init(
self,
env,
gamma=0.99,
epsilon=1e-8,
):
super().init(env)
self.num_envs = getattr(env, "num_envs", 1)
self.is_vector_env = getattr(env, "is_vector_env", False)
self.return_rms = RunningMeanStd(shape=())
self.returns = np.zeros(self.num_envs)
self.gamma = gamma
self.epsilon = epsilon

def step(self, action):
    obs, rews, dones, infos = self.env.step(action)
    if not self.is_vector_env:
        rews = np.array([rews])
    self.returns = self.returns * self.gamma + rews
    rews = self.normalize(rews)
    self.returns[dones] = 0.0
    if not self.is_vector_env:
        rews = rews[0]
    return obs, rews, dones, infos

def normalize(self, rews):
    self.return_rms.update(self.returns)
    return rews / np.sqrt(self.return_rms.var + self.epsilon)

and I can't also render. Whenever I call env.render(), it throws the same error- not implemented. Please help!