Following this instruction :
1. Strictly adhere to PEP-8 standards, ensuring code is clean, well-structured, and follows Python's style guide for readability.
2. Use appropriate modules like `typing` for type hints, ensuring code clarity, maintainability, and leveraging Python's standard libraries effectively.
3. Focus on time, space, robustness, scalability; write optimized, efficient code that can handle large datasets and scale seamlessly.
4. Implement comprehensive error handling, catching exceptions gracefully, providing meaningful error messages, and ensuring code robustness under unexpected conditions.
5. Ensure the developer agent writes advanced, maintainable Python code, balancing performance and readability while adhering to best practices.



TASK : PPOagent ,not working make below algoritmns ronbustness, learining , make algorithmns most advanced 

import gym
import numpy as np
import torch
import torch.nn as nn
import torch.optim as optim
from torch.distributions import Categorical
from typing import Any, Dict, List, Tuple
import logging


# Configure logging to replace print statements
logging.basicConfig(
    level=logging.INFO,  # Set to DEBUG for more detailed logs
    format='%(asctime)s - %(levelname)s - %(message)s',
    handlers=[
        logging.StreamHandler()
    ]
)


class Actor(nn.Module):
    """Actor network for PPO."""

    def __init__(self, state_dim: int, action_dim: int, hidden_dim: int = 64) -> None:
        super(Actor, self).__init__()
        self.network = nn.Sequential(
            nn.Linear(state_dim, hidden_dim),
            nn.Tanh(),
            nn.Linear(hidden_dim, hidden_dim),
            nn.Tanh(),
            nn.Linear(hidden_dim, action_dim),
            nn.Softmax(dim=-1)
        )

    def forward(self, state: torch.Tensor) -> torch.Tensor:
        return self.network(state)


class Critic(nn.Module):
    """Critic network for PPO."""

    def __init__(self, state_dim: int, hidden_dim: int = 64) -> None:
        super(Critic, self).__init__()
        self.network = nn.Sequential(
            nn.Linear(state_dim, hidden_dim),
            nn.Tanh(),
            nn.Linear(hidden_dim, hidden_dim),
            nn.Tanh(),
            nn.Linear(hidden_dim, 1)
        )

    def forward(self, state: torch.Tensor) -> torch.Tensor:
        return self.network(state)


class PPOAgent:
    """Proximal Policy Optimization (PPO) Agent."""

    def __init__(
        self,
        env: gym.Env,
        state_dim: int,
        action_dim: int,
        actor_lr: float = 3e-4,
        critic_lr: float = 1e-3,
        gamma: float = 0.99,
        lam: float = 0.95,
        epsilon: float = 0.2,
        epochs: int = 10,
        batch_size: int = 64,
        device: str = 'cpu'
    ) -> None:
        self.env = env
        self.device = torch.device(device)
        self.gamma = gamma
        self.lam = lam
        self.epsilon = epsilon
        self.epochs = epochs
        self.batch_size = batch_size

        self.actor = Actor(state_dim, action_dim).to(self.device)
        self.critic = Critic(state_dim).to(self.device)

        self.actor_optimizer = optim.Adam(self.actor.parameters(), lr=actor_lr)
        self.critic_optimizer = optim.Adam(self.critic.parameters(), lr=critic_lr)

    def select_action(self, state: np.ndarray) -> Tuple[int, float, np.ndarray]:
        """
        Selects an action based on the current policy.

        Returns:
            action (int): Selected action.
            log_prob (float): Log probability of the selected action.
            probs (np.ndarray): Action probabilities.
        """
        if isinstance(state, tuple):
            # For Gym versions >=0.26, state may be a tuple
            state = state[0]
        state = np.array(state)  # Ensure state is a NumPy array

        try:
            state_tensor = torch.from_numpy(state).float().unsqueeze(0).to(self.device)
        except Exception as e:
            logging.error(f"Error converting state to tensor: {e}")
            raise

        with torch.no_grad():
            probs = self.actor(state_tensor)

        if probs.dim() == 1:
            # Ensure probs has batch dimension
            probs = probs.unsqueeze(0)

        dist = Categorical(probs)
        action = dist.sample()
        log_prob = dist.log_prob(action)

        return action.item(), log_prob.item(), probs.cpu().numpy()

    def compute_gae(
        self,
        rewards: List[float],
        dones: List[bool],
        values: List[float]
    ) -> List[float]:
        """
        Computes Generalized Advantage Estimation (GAE).

        Args:
            rewards (List[float]): Rewards collected.
            dones (List[bool]): Done flags.
            values (List[float]): Estimated state values.

        Returns:
            List[float]: Advantage estimates.
        """
        advantages = []
        gae = 0.0
        next_value = 0.0
        for step in reversed(range(len(rewards))):
            mask = 1.0 - float(dones[step])
            delta = rewards[step] + self.gamma * next_value * mask - values[step]
            gae = delta + self.gamma * self.lam * mask * gae
            advantages.insert(0, gae)
            next_value = values[step]
        return advantages

    def update(
        self,
        trajectories: Dict[str, List[Any]]
    ) -> None:
        """
        Updates the policy and value networks using the collected trajectories.

        Args:
            trajectories (Dict[str, List[Any]]): Collected trajectory data.
        """
        if len(trajectories['states']) == 0:
            logging.warning("No trajectories to update.")
            return

        # Convert lists to NumPy arrays first for efficiency
        try:
            states = torch.from_numpy(np.array(trajectories['states'])).float().to(self.device)
            actions = torch.from_numpy(np.array(trajectories['actions'])).long().to(self.device)
            old_log_probs = torch.from_numpy(np.array(trajectories['log_probs'])).float().to(self.device)
            returns = torch.from_numpy(np.array(trajectories['returns'])).float().to(self.device)
            advantages = torch.from_numpy(np.array(trajectories['advantages'])).float().to(self.device)
            advantages = (advantages - advantages.mean()) / (advantages.std() + 1e-8)
        except Exception as e:
            logging.error(f"Error during tensor conversion: {e}")
            raise

        # Debugging statements
        logging.debug(f"Update - States shape: {states.shape}")
        logging.debug(f"Update - Actions shape: {actions.shape}")
        logging.debug(f"Update - Old Log Probs shape: {old_log_probs.shape}")
        logging.debug(f"Update - Returns shape: {returns.shape}")
        logging.debug(f"Update - Advantages shape: {advantages.shape}")

        dataset_size = states.size(0)
        for epoch in range(self.epochs):
            indices = np.arange(dataset_size)
            np.random.shuffle(indices)
            for start in range(0, dataset_size, self.batch_size):
                end = start + self.batch_size
                batch_indices = indices[start:end]

                batch_states = states[batch_indices]
                batch_actions = actions[batch_indices]
                batch_old_log_probs = old_log_probs[batch_indices]
                batch_returns = returns[batch_indices]
                batch_advantages = advantages[batch_indices]

                # Actor loss
                probs = self.actor(batch_states)
                dist = Categorical(probs)
                entropy = dist.entropy().mean()
                new_log_probs = dist.log_prob(batch_actions)
                ratio = torch.exp(new_log_probs - batch_old_log_probs)
                surrogate1 = ratio * batch_advantages
                surrogate2 = torch.clamp(ratio, 1.0 - self.epsilon, 1.0 + self.epsilon) * batch_advantages
                actor_loss = -torch.min(surrogate1, surrogate2).mean() - 0.01 * entropy

                # Critic loss
                value = self.critic(batch_states).squeeze()
                critic_loss = nn.MSELoss()(value, batch_returns)

                # Update actor
                self.actor_optimizer.zero_grad()
                actor_loss.backward()
                self.actor_optimizer.step()

                # Update critic
                self.critic_optimizer.zero_grad()
                critic_loss.backward()
                self.critic_optimizer.step()

    def train(self, num_episodes: int = 1000, render_freq: int = 100) -> None:
        """
        Trains the PPO agent.

        Args:
            num_episodes (int): Number of episodes to train.
            render_freq (int): Frequency of rendering (e.g., every 'render_freq' episodes).
        """
        for episode in range(num_episodes):
            reset_return = self.env.reset()
            if isinstance(reset_return, tuple) and len(reset_return) == 2:
                state, _ = reset_return
            else:
                state = reset_return

            trajectories = {
                'states': [],
                'actions': [],
                'log_probs': [],
                'rewards': [],
                'dones': [],
                'values': []
            }
            done = False
            truncated = False
            total_reward = 0
            step_count = 0
            while not (done or truncated):
                # Render the environment every 'render_freq' episodes
                if (episode % render_freq == 0) and (episode != 0):
                    self.env.render()

                action, log_prob, _ = self.select_action(state)

                # Step the environment
                step_return = self.env.step(action)
                if len(step_return) == 5:
                    next_state, reward, done, truncated, _ = step_return
                elif len(step_return) == 4:
                    next_state, reward, done, _ = step_return
                    truncated = False  # Default to False if 'truncated' not provided
                else:
                    logging.error(f"Unexpected number of return values from env.step(): {len(step_return)}")
                    break

                # Estimate the value of the current state
                try:
                    value_tensor = self.critic(
                        torch.from_numpy(np.array(state)).float().unsqueeze(0).to(self.device)
                    )
                    value = value_tensor.item()
                except Exception as e:
                    logging.error(f"Error during value estimation: {e}")
                    break

                # Store trajectory
                trajectories['states'].append(state)
                trajectories['actions'].append(action)
                trajectories['log_probs'].append(log_prob)
                trajectories['rewards'].append(reward)
                trajectories['dones'].append(done or truncated)
                trajectories['values'].append(value)

                state = next_state
                total_reward += reward
                step_count += 1

                # Optional: Limit steps per episode to avoid excessively long episodes
                if hasattr(self.env, 'spec') and self.env.spec.max_episode_steps is not None:
                    if step_count >= self.env.spec.max_episode_steps:
                        break

            # Compute advantages and returns
            values = trajectories['values']
            rewards = trajectories['rewards']
            dones = trajectories['dones']
            advantages = self.compute_gae(rewards, dones, values)
            returns = [adv + val for adv, val in zip(advantages, values)]

            trajectories['advantages'] = advantages
            trajectories['returns'] = returns

            # Update policy and value function
            self.update(trajectories)

            # Logging
            logging.info(f"Episode {episode + 1}/{num_episodes}, Total Reward: {total_reward}")

    def evaluate(self, num_episodes: int = 10, render: bool = True) -> None:
        """
        Evaluates the PPO agent.

        Args:
            num_episodes (int): Number of episodes to evaluate.
            render (bool): Whether to render the environment during evaluation.
        """
        for episode in range(num_episodes):
            reset_return = self.env.reset()
            if isinstance(reset_return, tuple) and len(reset_return) == 2:
                state, _ = reset_return
            else:
                state = reset_return

            done = False
            truncated = False
            total_reward = 0
            while not (done or truncated):
                if render:
                    self.env.render()

                state_tensor = torch.from_numpy(np.array(state)).float().unsqueeze(0).to(self.device)
                with torch.no_grad():
                    probs = self.actor(state_tensor)
                action = torch.argmax(probs, dim=-1).item()

                # Step the environment
                step_return = self.env.step(action)
                if len(step_return) == 5:
                    next_state, reward, done, truncated, _ = step_return
                elif len(step_return) == 4:
                    next_state, reward, done, _ = step_return
                    truncated = False  # Default to False if 'truncated' not provided
                else:
                    logging.error(f"Unexpected number of return values from env.step(): {len(step_return)}")
                    break

                state = next_state
                total_reward += reward

            logging.info(f"Evaluation Episode {episode + 1}/{num_episodes}, Total Reward: {total_reward}")


def main() -> None:
    """Main function to train and evaluate the PPO agent."""
    # Check Gym version
    try:
        import gym
        gym_version = gym.__version__
        logging.info(f"Gym version: {gym_version}")
    except ImportError:
        logging.error("Gym is not installed. Please install it using 'pip install gym'.")
        return

    # Determine major and minor version for conditional handling
    major_version = int(gym_version.split('.')[0])
    minor_version = int(gym_version.split('.')[1])

    # Determine render_mode based on Gym version
    if major_version > 0 or (major_version == 0 and minor_version >= 26):
        render_mode = 'human'
    else:
        render_mode = None

    try:
        # CartPole-v1, MountainCar-v0, Acrobot-v1,
        env_name = 'CartPole-v1'
        if render_mode:
            env = gym.make(env_name, render_mode=render_mode)
        else:
            env = gym.make(env_name)
    except gym.error.Error as e:
        logging.error(f"Error initializing environment '{env_name}': {e}")
        return

    state_space = env.observation_space
    action_space = env.action_space

    # Validate state and action spaces
    if isinstance(state_space, gym.spaces.Box):
        state_dim = state_space.shape[0]
    else:
        logging.error("Unsupported state space type.")
        env.close()
        return

    if isinstance(action_space, gym.spaces.Discrete):
        action_dim = action_space.n
    else:
        logging.error("Only discrete action spaces are supported.")
        env.close()
        return

    agent = PPOAgent(
        env=env,
        state_dim=state_dim,
        action_dim=action_dim,
        device='cpu'  # Change to 'cuda' if GPU is available
    )

    try:
        agent.train(num_episodes=1000, render_freq=100)
        agent.evaluate(num_episodes=10, render=True)
    except Exception as e:
        logging.error(f"An error occurred during training/evaluation: {e}")
    finally:
        env.close()


if __name__ == "__main__":
    main()