Automatic JuliaFormatter.jl run

src/base.jl

@@ -6,7 +6,7 @@ using MacroTools: @forward
 
 using IntervalSets
 
-Random.rand(s::Union{Interval, Array{<:Interval}}) = rand(Random.GLOBAL_RNG, s)
+Random.rand(s::Union{Interval,Array{<:Interval}}) = rand(Random.GLOBAL_RNG, s)
 
 function Random.rand(rng::AbstractRNG, s::Interval)
     rand(rng) * (s.right - s.left) + s.left
@@ -26,7 +26,7 @@ struct WorldSpace{T} end
 
 WorldSpace() = WorldSpace{Any}()
 
-Base.in(x, ::WorldSpace{T}) where T = x isa T
+Base.in(x, ::WorldSpace{T}) where {T} = x isa T
 
 #####
 # ZeroTo
@@ -39,16 +39,16 @@ Similar to `Base.OneTo`. Useful when wrapping third-party environments.
 """
 struct ZeroTo{T<:Integer} <: AbstractUnitRange{T}
     stop::T
-    ZeroTo{T}(n) where {T<:Integer} = new(max(zero(T)-one(T),n))
+    ZeroTo{T}(n) where {T<:Integer} = new(max(zero(T) - one(T), n))
 end
 
 ZeroTo(n::T) where {T<:Integer} = ZeroTo{T}(n)
 
 Base.show(io::IO, r::ZeroTo) = print(io, "ZeroTo(", r.stop, ")")
-Base.length(r::ZeroTo{T}) where T = T(r.stop + one(r.stop))
-Base.first(r::ZeroTo{T}) where T = zero(r.stop)
+Base.length(r::ZeroTo{T}) where {T} = T(r.stop + one(r.stop))
+Base.first(r::ZeroTo{T}) where {T} = zero(r.stop)
 
-function getindex(v::ZeroTo{T}, i::Integer) where T
+function getindex(v::ZeroTo{T}, i::Integer) where {T}
     Base.@_inline_meta
     @boundscheck ((i >= 0) & (i <= v.stop)) || throw_boundserror(v, i)
     convert(T, i)
@@ -76,15 +76,16 @@ Base.similar(s::Space, args...) = Space(similar(s.s, args...))
 
 Random.rand(s::Space) = rand(Random.GLOBAL_RNG, s)
 
-Random.rand(rng::AbstractRNG, s::Space) = map(s.s) do x
-    rand(rng, x)
-end
+Random.rand(rng::AbstractRNG, s::Space) =
+    map(s.s) do x
+        rand(rng, x)
+    end
 
-Random.rand(rng::AbstractRNG, s::Space{<:Dict}) = Dict(k=>rand(rng,v) for (k,v) in s.s)
+Random.rand(rng::AbstractRNG, s::Space{<:Dict}) = Dict(k => rand(rng, v) for (k, v) in s.s)
 
 function Base.in(X, S::Space)
     if length(X) == length(S.s)
-        for (x,s) in zip(X, S.s)
+        for (x, s) in zip(X, S.s)
             if x ∉ s
                 return false
             end

src/converters.jl

@@ -0,0 +1 @@
+

src/environments/3rd_party/atari.jl

@@ -57,12 +57,12 @@ function AtariEnv(;
     observation_size =
         grayscale_obs ? (getScreenWidth(ale), getScreenHeight(ale)) :
         (3, getScreenWidth(ale), getScreenHeight(ale))  # !!! note the order
-    observation_space = Space(
-        ClosedInterval{Cuchar}.(
-            fill(typemin(Cuchar), observation_size),
-            fill(typemax(Cuchar), observation_size),
-        )
-    )
+    observation_space = Space(ClosedInterval{
+        Cuchar,
+    }.(
+        fill(typemin(Cuchar), observation_size),
+        fill(typemax(Cuchar), observation_size),
+    ))
 
     actions = full_action_space ? getLegalActionSet(ale) : getMinimalActionSet(ale)
     action_space = Base.OneTo(length(actions))
@@ -165,16 +165,14 @@ end
 
 function Base.show(io::IO, m::MIME"image/png", env::AtariEnv)
     x = getScreenRGB(env.ale)
-    p=imshowcolor(x, (Int(getScreenWidth(env.ale)), Int(getScreenHeight(env.ale))))
+    p = imshowcolor(x, (Int(getScreenWidth(env.ale)), Int(getScreenHeight(env.ale))))
     show(io, m, p)
 end
 
 Base.show(io::IO, t::MIME"text/plain", env::AbstractEnv) = show(
-    IOContext(
-        io,
-        :is_show_state => false,
-        :is_show_state_space => false),
+    IOContext(io, :is_show_state => false, :is_show_state_space => false),
     MIME"text/markdown"(),
-    env)
+    env,
+)
 
 list_atari_rom_names() = getROMList()

src/environments/3rd_party/gym.jl

@@ -96,7 +96,7 @@ Random.seed!(env::GymEnv, s) = env.pyenv.seed(s)
 function space_transform(s::PyObject)
     spacetype = s.__class__.__name__
     if spacetype == "Box"
-        Space(ClosedInterval.(s.low,s.high))
+        Space(ClosedInterval.(s.low, s.high))
     elseif spacetype == "Discrete"  # for GymEnv("CliffWalking-v0"), `s.n` is of type PyObject (numpy.int64)
         ZeroTo(py"int($s.n)" - 1)
     elseif spacetype == "MultiBinary"

src/environments/3rd_party/open_spiel.jl

@@ -44,10 +44,7 @@ using StatsBase: sample, weights
   `True` or `False` (instead of `true` or `false`). Another approach is to just
   specify parameters in `kwargs` in the Julia style.
 """
-function OpenSpielEnv(
-    name="kuhn_poker";
-    kwargs...,
-)
+function OpenSpielEnv(name = "kuhn_poker"; kwargs...)
     game = load_game(String(name); kwargs...)
     state = new_initial_state(game)
     OpenSpielEnv(state, game)
@@ -65,21 +62,21 @@ RLBase.players(env::OpenSpielEnv) = 0:(num_players(env.game)-1)
 
 function RLBase.action_space(env::OpenSpielEnv, player)
     if player == chance_player(env)
-        [k for (k,v) in chance_outcomes(env.state)]
+        [k for (k, v) in chance_outcomes(env.state)]
     else
-        ZeroTo(num_distinct_actions(env.game)-1)
+        ZeroTo(num_distinct_actions(env.game) - 1)
     end
 end
 
 function RLBase.legal_action_space(env::OpenSpielEnv, player)
     if player == chance_player(env)
-        [k for (k,v) in chance_outcomes(env.state)]
+        [k for (k, v) in chance_outcomes(env.state)]
     else
         legal_actions(env.state, player)
     end
 end
 
-RLBase.prob(env::OpenSpielEnv, player) = [v for (k,v) in chance_outcomes(env.state)]
+RLBase.prob(env::OpenSpielEnv, player) = [v for (k, v) in chance_outcomes(env.state)]
 
 function RLBase.legal_action_space_mask(env::OpenSpielEnv, player)
     n =
@@ -107,7 +104,7 @@ end
 
 function RLBase.state(env::OpenSpielEnv, ss::RLBase.AbstractStateStyle, player)
     if player < 0  # TODO: revisit this in [email protected]
-        @warn "unexpected player $player, falling back to default state value." maxlog=1
+        @warn "unexpected player $player, falling back to default state value." maxlog = 1
         s = state_space(env)
         if s isa WorldSpace
             ""
@@ -119,13 +116,28 @@ function RLBase.state(env::OpenSpielEnv, ss::RLBase.AbstractStateStyle, player)
     end
 end
 
-_state(env::OpenSpielEnv, ::RLBase.InformationSet{String}, player) = information_state_string(env.state, player)
-_state(env::OpenSpielEnv, ::RLBase.InformationSet{Array}, player) = information_state_tensor(env.state, player)
-_state(env::OpenSpielEnv, ::Observation{String}, player) = observation_string(env.state, player)
-_state(env::OpenSpielEnv, ::Observation{Array}, player) = observation_tensor(env.state, player)
-
-RLBase.state_space(env::OpenSpielEnv, ::Union{InformationSet{String},Observation{String}}, p) = WorldSpace{AbstractString}()
-RLBase.state_space(env::OpenSpielEnv, ::Union{InformationSet{Array},Observation{Array}}, p) = Space(fill(typemin(Float64)..typemax(Float64), information_state_tensor_size(env.state)))
+_state(env::OpenSpielEnv, ::RLBase.InformationSet{String}, player) =
+    information_state_string(env.state, player)
+_state(env::OpenSpielEnv, ::RLBase.InformationSet{Array}, player) =
+    information_state_tensor(env.state, player)
+_state(env::OpenSpielEnv, ::Observation{String}, player) =
+    observation_string(env.state, player)
+_state(env::OpenSpielEnv, ::Observation{Array}, player) =
+    observation_tensor(env.state, player)
+
+RLBase.state_space(
+    env::OpenSpielEnv,
+    ::Union{InformationSet{String},Observation{String}},
+    p,
+) = WorldSpace{AbstractString}()
+RLBase.state_space(
+    env::OpenSpielEnv,
+    ::Union{InformationSet{Array},Observation{Array}},
+    p,
+) = Space(fill(
+    typemin(Float64)..typemax(Float64),
+    information_state_tensor_size(env.state),
+))
 
 Random.seed!(env::OpenSpielEnv, s) = @warn "seed!(OpenSpielEnv) is not supported currently."
 
@@ -154,10 +166,16 @@ function RLBase.UtilityStyle(env::OpenSpielEnv)
 end
 
 RLBase.ActionStyle(env::OpenSpielEnv) = FULL_ACTION_SET
-RLBase.DynamicStyle(env::OpenSpielEnv) = dynamics(get_type(env.game))== OpenSpiel.SEQUENTIAL ? RLBase.SEQUENTIAL : RLBase.SIMULTANEOUS
-RLBase.InformationStyle(env::OpenSpielEnv) = information(get_type(env.game)) ==OpenSpiel.PERFECT_INFORMATION ? RLBase.PERFECT_INFORMATION : RLBase.IMPERFECT_INFORMATION
+RLBase.DynamicStyle(env::OpenSpielEnv) =
+    dynamics(get_type(env.game)) == OpenSpiel.SEQUENTIAL ? RLBase.SEQUENTIAL :
+    RLBase.SIMULTANEOUS
+RLBase.InformationStyle(env::OpenSpielEnv) =
+    information(get_type(env.game)) == OpenSpiel.PERFECT_INFORMATION ?
+    RLBase.PERFECT_INFORMATION : RLBase.IMPERFECT_INFORMATION
 RLBase.NumAgentStyle(env::OpenSpielEnv) = MultiAgent(num_players(env.game))
-RLBase.RewardStyle(env::OpenSpielEnv) = reward_model(get_type(env.game)) == OpenSpiel.REWARDS ? RLBase.STEP_REWARD : RLBase.TERMINAL_REWARD
+RLBase.RewardStyle(env::OpenSpielEnv) =
+    reward_model(get_type(env.game)) == OpenSpiel.REWARDS ? RLBase.STEP_REWARD :
+    RLBase.TERMINAL_REWARD
 
 RLBase.StateStyle(env::OpenSpielEnv) = (
     RLBase.InformationSet{String}(),

src/environments/environments.jl

@@ -1,4 +1,4 @@
 include("examples/examples.jl")
 include("non_interactive/non_interactive.jl")
 include("wrappers/wrappers.jl")
-include("3rd_party/structs.jl")
+include("3rd_party/structs.jl")

src/environments/examples/AcrobotEnv.jl

@@ -115,7 +115,7 @@ acrobot_observation(s) = [cos(s[1]), sin(s[1]), cos(s[2]), sin(s[2]), s[3], s[4]
 
 RLBase.action_space(env::AcrobotEnv) = Base.OneTo(3)
 
-function RLBase.state_space(env::AcrobotEnv{T}) where T
+function RLBase.state_space(env::AcrobotEnv{T}) where {T}
     high = [1.0, 1.0, 1.0, 1.0, env.params.max_vel_a, env.params.max_vel_b]
     Space(ClosedInterval{T}.(-high, high))
 end

src/environments/examples/CartPoleEnv.jl

@@ -66,15 +66,7 @@ function CartPoleEnv(;
         2.4,
         max_steps,
     )
-    high = 
-    cp = CartPoleEnv(
-        params,
-        zeros(T, 4),
-        2,
-        false,
-        0,
-        rng,
-    )
+    high = cp = CartPoleEnv(params, zeros(T, 4), 2, false, 0, rng)
     reset!(cp)
     cp
 end
@@ -91,14 +83,12 @@ end
 
 RLBase.action_space(env::CartPoleEnv) = Base.OneTo(2)
 
-RLBase.state_space(env::CartPoleEnv{T}) where T = Space(
-    ClosedInterval{T}[
-        (-2 * env.params.xthreshold)..(2 * env.params.xthreshold),
-        -1e38..1e38,
-        (-2 * env.params.thetathreshold)..(2 * env.params.thetathreshold),
-        -1e38..1e38
-    ]
-)
+RLBase.state_space(env::CartPoleEnv{T}) where {T} = Space(ClosedInterval{T}[
+    (-2*env.params.xthreshold)..(2*env.params.xthreshold),
+    -1e38..1e38,
+    (-2*env.params.thetathreshold)..(2*env.params.thetathreshold),
+    -1e38..1e38,
+])
 
 RLBase.reward(env::CartPoleEnv{T}) where {T} = env.done ? zero(T) : one(T)
 RLBase.is_terminated(env::CartPoleEnv) = env.done

src/environments/examples/KuhnPokerEnv.jl

@@ -103,7 +103,8 @@ RLBase.state_space(env::KuhnPokerEnv, ::InformationSet{Tuple{Vararg{Symbol}}}, p
     KUHN_POKER_STATES
 
 RLBase.action_space(env::KuhnPokerEnv, ::Int) = Base.OneTo(length(KUHN_POKER_ACTIONS))
-RLBase.action_space(env::KuhnPokerEnv, ::ChancePlayer) = Base.OneTo(length(KUHN_POKER_CARDS))
+RLBase.action_space(env::KuhnPokerEnv, ::ChancePlayer) =
+    Base.OneTo(length(KUHN_POKER_CARDS))
 
 RLBase.legal_action_space(env::KuhnPokerEnv, p::ChancePlayer) =
     [x for x in action_space(env, p) if KUHN_POKER_CARDS[x] ∉ env.cards]

src/environments/examples/TicTacToeEnv.jl

@@ -75,8 +75,10 @@ RLBase.current_player(env::TicTacToeEnv) = env.player
 RLBase.players(env::TicTacToeEnv) = (CROSS, NOUGHT)
 
 RLBase.state(env::TicTacToeEnv, ::Observation{BitArray{3}}, p) = env.board
-RLBase.state_space(env::TicTacToeEnv, ::Observation{BitArray{3}}, p) = Space(fill(false..true, 3, 3, 3))
-RLBase.state(env::TicTacToeEnv, ::Observation{Int}, p) = get_tic_tac_toe_state_info()[env].index
+RLBase.state_space(env::TicTacToeEnv, ::Observation{BitArray{3}}, p) =
+    Space(fill(false..true, 3, 3, 3))
+RLBase.state(env::TicTacToeEnv, ::Observation{Int}, p) =
+    get_tic_tac_toe_state_info()[env].index
 RLBase.state_space(env::TicTacToeEnv, ::Observation{Int}, p) =
     Base.OneTo(length(get_tic_tac_toe_state_info()))
 

src/environments/examples/TinyHanabiEnv.jl

@@ -56,7 +56,8 @@ RLBase.action_space(env::TinyHanabiEnv, ::Int) = Base.OneTo(3)
 RLBase.action_space(env::TinyHanabiEnv, ::ChancePlayer) = Base.OneTo(2)
 
 RLBase.legal_action_space(env::TinyHanabiEnv, ::ChancePlayer) = findall(!in(env.cards), 1:2)
-RLBase.legal_action_space_mask(env::TinyHanabiEnv, ::ChancePlayer) = [x ∉ env.cards for x in 1:2]
+RLBase.legal_action_space_mask(env::TinyHanabiEnv, ::ChancePlayer) =
+    [x ∉ env.cards for x in 1:2]
 
 function RLBase.prob(env::TinyHanabiEnv, ::ChancePlayer)
     if isempty(env.cards)

src/environments/non_interactive/pendulum.jl

@@ -69,7 +69,8 @@ Random.seed!(env::PendulumNonInteractiveEnv, seed) = Random.seed!(env.rng, seed)
 RLBase.reward(env::PendulumNonInteractiveEnv) = 0
 RLBase.is_terminated(env::PendulumNonInteractiveEnv) = env.done
 RLBase.state(env::PendulumNonInteractiveEnv) = env.state
-RLBase.state_space(env::PendulumNonInteractiveEnv{T}) where T = Space([typemin(T)..typemax(T), typemin(T)..typemax(T)])
+RLBase.state_space(env::PendulumNonInteractiveEnv{T}) where {T} =
+    Space([typemin(T)..typemax(T), typemin(T)..typemax(T)])
 
 function RLBase.reset!(env::PendulumNonInteractiveEnv{Fl}) where {Fl}
     env.state .= (Fl(2 * pi) * rand(env.rng, Fl), randn(env.rng, Fl))

src/environments/wrappers/ActionTransformedEnv.jl

@@ -13,7 +13,11 @@ end
 `legal_action_space(env)`. `action_mapping` will be applied to `action` before
 feeding it into `env`.
 """
-function ActionTransformedEnv(env; action_space_mapping=identity, action_mapping=identity)
+function ActionTransformedEnv(
+    env;
+    action_space_mapping = identity,
+    action_mapping = identity,
+)
     ActionTransformedEnv(action_space_mapping, action_mapping, env)
 end
 
@@ -25,9 +29,13 @@ for f in vcat(RLBase.ENV_API, RLBase.MULTI_AGENT_ENV_API)
 end
 
 RLBase.state(env::ActionTransformedEnv, ss::RLBase.AbstractStateStyle) = state(env.env, ss)
-RLBase.state_space(env::ActionTransformedEnv, ss::RLBase.AbstractStateStyle) = state_space(env.env, ss)
+RLBase.state_space(env::ActionTransformedEnv, ss::RLBase.AbstractStateStyle) =
+    state_space(env.env, ss)
 
-RLBase.action_space(env::ActionTransformedEnv) = env.action_space_mapping(action_space(env.env))
-RLBase.legal_action_space(env::ActionTransformedEnv) = env.action_space_mapping(legal_action_space(env.env))
+RLBase.action_space(env::ActionTransformedEnv) =
+    env.action_space_mapping(action_space(env.env))
+RLBase.legal_action_space(env::ActionTransformedEnv) =
+    env.action_space_mapping(legal_action_space(env.env))
 
-(env::ActionTransformedEnv)(action, args...; kwargs...) = env.env(env.action_mapping(action), args...; kwargs...)
+(env::ActionTransformedEnv)(action, args...; kwargs...) =
+    env.env(env.action_mapping(action), args...; kwargs...)

src/environments/wrappers/DefaultStateStyle.jl

@@ -20,7 +20,8 @@ for f in vcat(RLBase.ENV_API, RLBase.MULTI_AGENT_ENV_API)
     end
 end
 
-(env::DefaultStateStyleEnv)(args...;kwargs...) = env.env(args...;kwargs...)
+(env::DefaultStateStyleEnv)(args...; kwargs...) = env.env(args...; kwargs...)
 
 RLBase.state(env::DefaultStateStyleEnv, ss::RLBase.AbstractStateStyle) = state(env.env, ss)
-RLBase.state_space(env::DefaultStateStyleEnv, ss::RLBase.AbstractStateStyle) = state_space(env.env, ss)
+RLBase.state_space(env::DefaultStateStyleEnv, ss::RLBase.AbstractStateStyle) =
+    state_space(env.env, ss)

src/environments/wrappers/MaxTimeoutEnv.jl

@@ -21,12 +21,15 @@ end
 
 for f in vcat(RLBase.ENV_API, RLBase.MULTI_AGENT_ENV_API)
     if f != :terminal
-        @eval RLBase.$f(x::MaxTimeoutEnv, args...; kwargs...) = $f(x.env, args...; kwargs...)
+        @eval RLBase.$f(x::MaxTimeoutEnv, args...; kwargs...) =
+            $f(x.env, args...; kwargs...)
     end
 end
 
-RLBase.is_terminated(env::MaxTimeoutEnv) = (env.current_t > env.max_t) || is_terminated(env.env)
+RLBase.is_terminated(env::MaxTimeoutEnv) =
+    (env.current_t > env.max_t) || is_terminated(env.env)
 
 
 RLBase.state(env::MaxTimeoutEnv, ss::RLBase.AbstractStateStyle) = state(env.env, ss)
-RLBase.state_space(env::MaxTimeoutEnv, ss::RLBase.AbstractStateStyle) = state_space(env.env, ss)
+RLBase.state_space(env::MaxTimeoutEnv, ss::RLBase.AbstractStateStyle) =
+    state_space(env.env, ss)

src/environments/wrappers/MultiThreadEnv.jl

@@ -122,7 +122,8 @@ end
 
 function RLBase.legal_action_space_mask(env::MultiThreadEnv)
     @sync for i in 1:length(env)
-        @spawn selectdim(env.legal_action_space_mask, N, i) .= legal_action_space_mask(env[i])
+        @spawn selectdim(env.legal_action_space_mask, N, i) .=
+            legal_action_space_mask(env[i])
     end
     env.legal_action_space_mask
 end
@@ -136,4 +137,4 @@ for f in RLBase.ENV_API
     if endswith(String(f), "Style")
         @eval RLBase.$f(x::MultiThreadEnv) = $f(x[1])
     end
-end
+end