gymnasium_env_base.h

Go to the documentation of this file.

#ifndef GYMNASIUM_ENV_BASE_H
#define GYMNASIUM_ENV_BASE_H
 
 
#include "bitrl/bitrl_config.h"
#include "bitrl/bitrl_consts.h"
#include "bitrl/bitrl_types.h"
#include "bitrl/envs/env_base.h"
#include "bitrl/extern/nlohmann/json/json.hpp"
#include "bitrl/network/rest_rl_env_client.h"
#include "bitrl/utils//std_map_utils.h"
 
#include <any>
#include <string>
#include <unordered_map>
 
#ifdef BITRL_DEBUG
#include <cassert>
#endif
 
namespace bitrl
{
namespace envs::gymnasium
{
template <typename TimeStepType, typename SpaceType>
class GymnasiumEnvBase : public EnvBase<TimeStepType, SpaceType>
{
  public:
    typedef EnvBase<TimeStepType, SpaceType> base_type;
 
    typedef typename base_type::time_step_type time_step_type;
 
    typedef typename base_type::state_space_type state_space_type;
 
    typedef typename base_type::action_space_type action_space_type;
 
    typedef typename base_type::action_type action_type;
 
    typedef typename base_type::state_type state_type;
 
    using base_type::reset;
 
    virtual ~GymnasiumEnvBase();
 
    virtual bool is_alive() const;
 
    virtual void close() override;
 
    virtual time_step_type reset() override;
 
    uint_t n_copies() const;
 
    network::RESTRLEnvClient &get_api_server() const { return *api_server_; }
 
    std::string get_url() const;
 
  protected:
    GymnasiumEnvBase(network::RESTRLEnvClient &api_server, const std::string &name);
 
    GymnasiumEnvBase(const GymnasiumEnvBase &);
 
    network::RESTRLEnvClient *api_server_;
 
    virtual time_step_type
    create_time_step_from_response_(const nlohmann::json &response) const = 0;
};
 
template <typename TimeStepType, typename SpaceType>
GymnasiumEnvBase<TimeStepType, SpaceType>::GymnasiumEnvBase(network::RESTRLEnvClient &api_server,
                                                            const std::string &name)
    : EnvBase<TimeStepType, SpaceType>(bitrl::consts::INVALID_STR, name), api_server_(&api_server)
{
}
 
template <typename TimeStepType, typename SpaceType>
GymnasiumEnvBase<TimeStepType, SpaceType>::GymnasiumEnvBase(
    const GymnasiumEnvBase<TimeStepType, SpaceType> &other)
    : EnvBase<TimeStepType, SpaceType>(other), api_server_(other.api_server_)
{
}
 
template <typename TimeStepType, typename SpaceType>
GymnasiumEnvBase<TimeStepType, SpaceType>::~GymnasiumEnvBase()
{
 
    try
    {
        close();
    }
    catch (...)
    {
    }
}
 
template <typename TimeStepType, typename SpaceType>
bool GymnasiumEnvBase<TimeStepType, SpaceType>::is_alive() const
{
    auto response = this->api_server_->is_alive(this->env_name(), this->idx());
    return response["result"];
}
template <typename TimeStepType, typename SpaceType>
uint_t GymnasiumEnvBase<TimeStepType, SpaceType>::n_copies() const
{
    auto response = this->api_server_->n_copies(this->env_name());
    return response["copies"];
}
 
template <typename TimeStepType, typename SpaceType>
void GymnasiumEnvBase<TimeStepType, SpaceType>::close()
{
 
    if (!this->is_created())
    {
        return;
    }
 
    auto response = this->api_server_->close(this->env_name(), this->idx());
    this->invalidate_is_created_flag_();
}
 
template <typename TimeStepType, typename SpaceType>
typename GymnasiumEnvBase<TimeStepType, SpaceType>::time_step_type
GymnasiumEnvBase<TimeStepType, SpaceType>::reset()
{
 
    if (!this->is_created())
    {
#ifdef BITRL_DEBUG
        assert(this->is_created() && "Environment has not been created");
#endif
        return time_step_type();
    }
 
    auto &reset_ops = this->reset_options();
    auto seed = utils::resolve<uint_t>("seed", reset_ops);
 
    auto response = this->api_server_->reset(this->env_name(), this->idx(), seed, nlohmann::json());
 
    this->get_current_time_step_() = this->create_time_step_from_response_(response);
    return this->get_current_time_step_();
}
 
template <typename TimeStepType, typename SpaceType>
std::string GymnasiumEnvBase<TimeStepType, SpaceType>::get_url() const
{
    return api_server_->get_env_url(this->env_name());
}
 
} // namespace envs::gymnasium
} // namespace bitrl
 
#endif // GYMNASIUMENVBASE_H