Executors

Type alias for any FOK order

Type alias for any GTC order

Type alias for any IOC order

Union type representing limit order increase operations. Includes Buy and Sell Short orders.

Union type representing limit trade increase operations. Includes Buy and Sell Short trades.

Some exchanges add funding rates and trading fees to the liquidation price, we use a default buffer of -0.02.

Union type representing limit order reduction operations. Includes Sell and Buy Short orders.

Union type representing limit trade reduction operations. Includes Sell and Buy Short trades.

Type alias for any limit order

Type alias for any market order

Type alias for any post only order

Action to cancel open orders.

The configuration against which a strategy is tested.

The Context struct has the following type parameter:

• M: a subtype of ExecMode.

The struct has the following fields:

• range: The date range to backtest around.

Create an instance of Context for a given strategy using the shortest timeframe.

Context(s::Strategies.Strategy) -> Executors.Context

The Context function takes the following parameters:

• s: a Strategy object of subtype ExecMode.

Action to initialize OHLCV data.

Type representing a limit buy trade, specific to long position buy limit orders.

Type representing a limit sell trade, specific to long position sell limit orders.

Type representing a limit trade, includes long position limit orders.

Defines a long market buy trade type.

Represents a long market sell trade on a certain exchange for a specific asset.

Action executed after a new trade occurs.

Action run before a single simulation during optimization.

Action to get the score of a single simulation (after it has finished).

Action to setup an optimizer (context and params).

A data structure for maintaining a collection of iterators.

• iters

Type representing a short limit buy trade, specific to short position buy limit orders.

Type representing a short limit sell trade, specific to short position sell limit orders.

Type representing a short limit trade, includes short position limit orders.

Action to update OHLCV data (from watchers).

Action to update leverage.

Action to update margin mode.

(DEPRECATED) order updates are done internally now.

(DEPRECATED) The shuffled version of UpdateOrders.

Action to update positions size.

Action to setup an OHLCV watcher.

Collects all elements of the OrderIterator into a Vector.

collect(
    oi::Executors.OrderIterator
) -> Vector{Pair{@NamedTuple{price::Float64, time::Dates.DateTime}, <:OrderTypes.Order}}

Counts the number of elements in the OrderIterator.

count(oi::Executors.OrderIterator) -> Int64

Removes a single order from the order queue.

delete!(
    s::Strategies.Strategy,
    ai,
    o::OrderTypes.IncreaseOrder
) -> Union{Nothing, Set{Instances.AssetInstance{T, E} where T<:AbstractAsset} where E<:ExchangeID}

Removes a single short buy order from the order queue.

delete!(
    s::Strategies.Strategy,
    ai,
    o::OrderTypes.Order{<:OrderTypes.OrderType{OrderTypes.Buy}, A, E, Misc.Short} where {A, E}
) -> Union{Nothing, Set{Instances.AssetInstance{T, E} where T<:AbstractAsset} where E<:ExchangeID}

Removes a single sell order from the order queue.

delete!(
    s::Strategies.Strategy,
    ai,
    o::OrderTypes.Order{<:OrderTypes.OrderType{OrderTypes.Sell}, A, E, Misc.Long} where {A, E}
) -> Union{Nothing, Set{Instances.AssetInstance{T, E} where T<:AbstractAsset} where E<:ExchangeID}

Removes all buy/sell orders for an asset instance.

delete!(
    s::Strategies.Strategy,
    ai,
    t::Type{<:Union{OrderTypes.Buy, OrderTypes.Sell}}
) -> Any

Removes all buy and sell orders for an asset instance.

delete!(
    s::Strategies.Strategy,
    ai,
    _::Type{OrderTypes.BuyOrSell}
) -> Any

Removes all orders for an asset instance.

delete!(s::Strategies.Strategy, ai) -> Any

Returns the element type of the OrderIterator.

eltype(
    _::Executors.OrderIterator
) -> Type{Pair{@NamedTuple{price::Float64, time::Dates.DateTime}, <:OrderTypes.Order}}

Fills a short buy order.

fill!(
    _::Strategies.Strategy{<:Union{Misc.Paper, Misc.Sim}},
    ai::Instances.AssetInstance,
    o::OrderTypes.Order{<:OrderTypes.OrderType{OrderTypes.Buy}, A, E, Misc.Short} where {A, E},
    t::OrderTypes.ShortBuyTrade
)

Fills a sell order.

fill!(
    _::Strategies.Strategy{<:Union{Misc.Paper, Misc.Sim}},
    ai::Instances.AssetInstance,
    o::OrderTypes.Order{<:OrderTypes.OrderType{OrderTypes.Sell}, A, E, Misc.Long} where {A, E},
    t::OrderTypes.SellTrade
)

Fills a buy order for a no-margin strategy.

fill!(
    _::Strategies.Strategy{<:Union{Misc.Paper, Misc.Sim}},
    ai::Instances.AssetInstance{<:AbstractAsset, <:ExchangeID, NoMargin},
    o::OrderTypes.Order{<:OrderTypes.OrderType{OrderTypes.Buy}, A, E, Misc.Long} where {A, E},
    t::OrderTypes.BuyTrade
)

Fills an increase order for a margin strategy.

fill!(
    _::Strategies.Strategy{var"#s238", N, <:ExchangeID, <:Misc.WithMargin, C} where {var"#s238"<:Union{Misc.Paper, Misc.Sim}, N, C},
    ai::Instances.AssetInstance{<:AbstractAsset, <:ExchangeID, M} where M<:Misc.WithMargin,
    o::OrderTypes.IncreaseOrder,
    t::OrderTypes.IncreaseTrade
)

Returns the first order for an asset in a strategy.

first(s::Strategies.Strategy{M, S, E}, ai) -> Any
first(
    s::Strategies.Strategy{M, S, E},
    ai,
    bs::OrderTypes.BySide
) -> Any

Returns the first index for an order for an asset in a strategy.

firstindex(s::Strategies.Strategy{M, S, E}, ai) -> Any
firstindex(
    s::Strategies.Strategy{M, S, E},
    ai,
    bs::OrderTypes.BySide
) -> Any

Checks if a strategy has a specific order for an asset by price and time.

haskey(
    s::Strategies.Strategy,
    ai,
    pt::@NamedTuple{price::Float64, time::Dates.DateTime},
    _::Union{Type{OrderTypes.BuyOrSell}, OrderTypes.BuyOrSell, Type{<:OrderTypes.Order{<:OrderTypes.OrderType{OrderTypes.BuyOrSell}}}, OrderTypes.Order{<:OrderTypes.OrderType{OrderTypes.BuyOrSell}}, OrderTypes.Trade{<:OrderTypes.OrderType{OrderTypes.BuyOrSell}}}
) -> Bool

Checks if a strategy has a specific order for an asset by price and time.

haskey(
    s::Strategies.Strategy,
    ai,
    pt::@NamedTuple{price::Float64, time::Dates.DateTime},
    side::Union{Type{var"#s238"}, Type{<:OrderTypes.Order{<:OrderTypes.OrderType{var"#s238"}}}, OrderTypes.Order{<:OrderTypes.OrderType{var"#s238"}}, OrderTypes.Trade{<:OrderTypes.OrderType{var"#s238"}}, var"#s238"} where var"#s238"<:Union{OrderTypes.Buy, OrderTypes.Sell}
) -> Bool

Checks if a strategy has a specific order for an asset by price and time.

haskey(
    s::Strategies.Strategy,
    ai,
    pt::@NamedTuple{price::Float64, time::Dates.DateTime}
) -> Bool

Checks if a strategy has a specific order for an asset.

haskey(
    s::Strategies.Strategy,
    ai,
    o::OrderTypes.Order
) -> Bool

Checks if the OrderIterator is empty.

isdone(oi::Executors.OrderIterator) -> Bool

Checks if an order is open.

isopen(
    ai::Instances.AssetInstance,
    o::OrderTypes.Order
) -> Any

Checks if the order amount left to fill is below minimum qty.

iszero(
    ai::Instances.AssetInstance,
    o::OrderTypes.Order
) -> Any

Returns the next element in the OrderIterator.

iterate(
    oi::Executors.OrderIterator,
    _
) -> Union{Nothing, Tuple{Any, Nothing}}

Returns all keys for orders in a strategy.

keys(
    s::Strategies.Strategy,
    args...;
    kwargs...
) -> Union{Base.Generator{_A, Executors.var"#59#60"} where _A, DiskArrays.DiskGenerator{I, Executors.var"#59#60"} where I<:DiskArrays.AbstractDiskArray}

Returns the last element in the OrderIterator.

last(oi::Executors.OrderIterator) -> Any

Returns the last order for an asset in a strategy.

last(s::Strategies.Strategy{M, S, E}, ai) -> Any
last(
    s::Strategies.Strategy{M, S, E},
    ai,
    bs::OrderTypes.BySide
) -> Any

Returns the last index for an order for an asset in a strategy.

lastindex(s::Strategies.Strategy{M, S, E}, ai) -> Any
lastindex(
    s::Strategies.Strategy{M, S, E},
    ai,
    bs::OrderTypes.BySide
) -> Any

Inserts an order into the order dict of the asset instance. Orders should be identifiable by a unique (price, date) tuple.

push!(
    s::Strategies.Strategy,
    ai,
    o::OrderTypes.Order{<:OrderTypes.OrderType{S<:OrderTypes.OrderSide}}
) -> OrderTypes.Order{<:OrderTypes.OrderType{S}} where S<:OrderTypes.OrderSide

Returns all values for orders in a strategy.

values(
    s::Strategies.Strategy,
    args...;
    kwargs...
) -> Union{Base.Generator{_A, Executors.var"#62#63"} where _A, DiskArrays.DiskGenerator{I, Executors.var"#62#63"} where I<:DiskArrays.AbstractDiskArray}

Returns the cost of an order.

cost(o::OrderTypes.Order) -> Float64

Checks the cash for an asset instance in a strategy for long.

_check_cash(ai::Instances.AssetInstance, _::Misc.Long)

Checks the cash for an asset instance in a strategy for short.

_check_cash(ai::Instances.AssetInstance, _::Misc.Short)

Checks order committment to be within expected values.

_check_committment(o)

Checks a buy trade.

_check_trade(t::OrderTypes.BuyTrade, ai)

Checks a sell trade.

_check_trade(t::OrderTypes.SellTrade, ai)

Checks a short buy trade.

_check_trade(t::OrderTypes.ShortBuyTrade, ai)

Checks a short sell trade.

_check_trade(t::OrderTypes.ShortSellTrade, ai)

Checks if the unfilled amount for a limit buy order is negative.

_check_unfillment(
    o::OrderTypes.AnyBuyOrder{P, <:AbstractAsset, <:ExchangeID, var"#s1940"} where {P<:Misc.PositionSide, var"#s1940"<:OrderTypes.LimitOrderType{OrderTypes.Buy}}
) -> Any

Checks if the unfilled amount for a market buy order is negative.

_check_unfillment(
    o::OrderTypes.AnyBuyOrder{P, <:AbstractAsset, <:ExchangeID, var"#s1940"} where {P<:Misc.PositionSide, var"#s1940"<:OrderTypes.MarketOrderType{OrderTypes.Buy}}
) -> Any

Checks if the unfilled amount for a limit sell order is positive.

_check_unfillment(
    o::OrderTypes.AnySellOrder{P, <:AbstractAsset, <:ExchangeID, var"#s1940"} where {P<:Misc.PositionSide, var"#s1940"<:OrderTypes.LimitOrderType{OrderTypes.Sell}}
) -> Any

Checks if the unfilled amount for a market sell order is positive.

_check_unfillment(
    o::OrderTypes.AnySellOrder{P, <:AbstractAsset, <:ExchangeID, var"#s1940"} where {P<:Misc.PositionSide, var"#s1940"<:OrderTypes.MarketOrderType{OrderTypes.Sell}}
) -> Any

Checks if the unfilled amount for a long order is positive.

_check_unfillment(o::OrderTypes.LongOrder) -> Any

Checks if the unfilled amount for a short order is negative.

_check_unfillment(o::OrderTypes.ShortOrder) -> Any

Filters out empty iterators and returns the smallest value.

_do_orders_iter(oi) -> Union{Nothing, Tuple{Any, Nothing}}

Clamps the given values within the correct boundaries.

_doclamp(clamper, ai, whats...) -> Expr

Finds and returns the iterator with the smallest value.

_findmin(non_empty_iters) -> Tuple{Any, Any}

Unconditionally dequeues immediate orders.

aftertrade!(
    s::Strategies.Strategy,
    ai,
    o::Union{OrderTypes.Order{<:OrderTypes.MarketOrderType{S}, <:AbstractAsset, <:ExchangeID, P} where {S<:OrderTypes.OrderSide, P<:Misc.PositionSide}, OrderTypes.FOKOrder, OrderTypes.IOCOrder, OrderTypes.ShortFOKOrder, OrderTypes.ShortIOCOrder}
) -> Any
aftertrade!(
    s::Strategies.Strategy,
    ai,
    o::Union{OrderTypes.Order{<:OrderTypes.MarketOrderType{S}, <:AbstractAsset, <:ExchangeID, P} where {S<:OrderTypes.OrderSide, P<:Misc.PositionSide}, OrderTypes.FOKOrder, OrderTypes.IOCOrder, OrderTypes.ShortFOKOrder, OrderTypes.ShortIOCOrder},
    t
) -> Any

This function is called after a trade to remove filled 'Fill Or Kill' (FOK) or 'Immediate Or Cancel' (IOC) orders from the strategy's order queue.

Removes a filled limit order from the queue

aftertrade!(
    s::Strategies.Strategy,
    ai,
    o::OrderTypes.Order
) -> Any
aftertrade!(
    s::Strategies.Strategy,
    ai,
    o::OrderTypes.Order,
    t
) -> Any

The function is used post-trade to clean up the strategy's order queue.

Performs cleanups after a trade (attempt).

aftertrade!(s, ai, o) -> Any
aftertrade!(s, ai, o, t) -> Any

Returns the amount of an order.

amount(o::OrderTypes.Order) -> Float64

Constructs a basic order state with given parameters.

basic_order_state(
    take,
    stop,
    committed::Ref{T<:Real},
    unfilled::Ref{T<:Real}
) -> NamedTuple{(:take, :stop, :committed, :unfilled, :trades), T1} where {T<:Real, T1<:Union{Tuple{Nothing, Nothing, Ref{T}, Ref{T}, Vector{OrderTypes.Trade}}, Tuple{Nothing, Real, Ref{T}, Ref{T}, Vector{OrderTypes.Trade}}, Tuple{Real, Nothing, Ref{T}, Ref{T}, Vector{OrderTypes.Trade}}, Tuple{Real, Real, Ref{T}, Ref{T}, Vector{OrderTypes.Trade}}}}
basic_order_state(
    take,
    stop,
    committed::Ref{T<:Real},
    unfilled::Ref{T<:Real},
    trades
) -> NamedTuple{(:take, :stop, :committed, :unfilled, :trades), T1} where {T<:Real, T1<:Union{Tuple{Nothing, Nothing, Ref{T}, Ref{T}, Vector{OrderTypes.Trade}}, Tuple{Nothing, Real, Ref{T}, Ref{T}, Vector{OrderTypes.Trade}}, Tuple{Real, Nothing, Ref{T}, Ref{T}, Vector{OrderTypes.Trade}}, Tuple{Real, Real, Ref{T}, Ref{T}, Vector{OrderTypes.Trade}}}}

Constructs an Order for a given OrderType type and inputs.

basicorder(
    ai::Instances.AssetInstance,
    price,
    amount,
    committed,
    ::Executors.Checks.SanitizeOff;
    type,
    date,
    loss,
    profit,
    id,
    tag
)

Returns buy orders for an asset in a strategy.

buyorders(
    s::Strategies.Strategy,
    ai
) -> SortedDict{@NamedTuple{price::Float64, time::Dates.DateTime}, D, Strategies.BuyPriceTimeOrdering} where D<:(OrderTypes.AnyBuyOrder{P, T, E} where {E<:ExchangeID, P<:Misc.PositionSide, T<:AbstractAsset})

Cancels an order with given error.

cancel!(
    s::Strategies.Strategy,
    o::OrderTypes.Order,
    ai;
    err
)

Calculates the commitment for an order.

committment(
    ai::Instances.AssetInstance,
    o::OrderTypes.Order;
    kwargs...
) -> Any

Calculates the partial commitment of a trade.

committment(
    ai::Instances.AssetInstance,
    t::OrderTypes.Trade
) -> Any

Calculates the commitment for a leveraged position.

committment(
    o::Type{<:OrderTypes.IncreaseOrder},
    ai::Instances.AssetInstance{<:AbstractAsset, <:ExchangeID, M} where M<:Misc.WithMargin,
    price,
    amount;
    ntl,
    fees,
    lev,
    kwargs...
) -> Any

Calculates the commitment for an increase order without margin.

committment(
    ::Type{<:OrderTypes.IncreaseOrder},
    ai::Instances.AssetInstance{<:AbstractAsset, <:ExchangeID, NoMargin},
    price,
    amount;
    kwargs...
) -> Any

Calculates the commitment when exiting a position for shorts.

committment(
    ::Type{<:OrderTypes.Order{<:OrderTypes.OrderType{OrderTypes.Buy}, A, E, Misc.Short} where {A, E}},
    ai,
    price,
    amount;
    fees_base,
    kwargs...
) -> Any

Calculates the commitment when exiting a position for longs.

committment(
    ::Type{<:OrderTypes.Order{<:OrderTypes.OrderType{OrderTypes.Sell}, A, E, Misc.Long} where {A, E}},
    ai,
    price,
    amount;
    fees_base,
    kwargs...
) -> Any

Decommits an increase order from a strategy.

decommit!(
    s::Strategies.Strategy,
    o::OrderTypes.IncreaseOrder,
    ai
) -> Float64
decommit!(
    s::Strategies.Strategy,
    o::OrderTypes.IncreaseOrder,
    ai,
    canceled
) -> Float64

Decommits a short buy order from an asset instance.

decommit!(
    s::Strategies.Strategy,
    o::OrderTypes.Order{<:OrderTypes.OrderType{OrderTypes.Buy}, A, E, Misc.Short} where {A, E},
    ai,
    args...
)

Decommits a sell order from an asset instance.

decommit!(
    s::Strategies.Strategy,
    o::OrderTypes.Order{<:OrderTypes.OrderType{OrderTypes.Sell}, A, E, Misc.Long} where {A, E},
    ai,
    args...
)

The sum of all the trades fees that have heppened for the order.

feespaid(o::OrderTypes.Order) -> Any

Returns the filled amount of an order.

filled_amount(o) -> Any

Checks if any of the holdings has non dust cash.

hascash(s::Strategies.Strategy) -> Bool

Checks if an asset instance has pending orders in a strategy.

hasorders(
    s::Strategies.Strategy,
    ai::Instances.AssetInstance
) -> Bool

Checks if there are any orders for a given position side

hasorders(
    s::Strategies.Strategy{X, N, <:ExchangeID, <:Misc.WithMargin, C} where {X<:Misc.ExecMode, N, C},
    ai,
    ps::Misc.PositionSide
) -> Bool

This function checks both Buy and Sell sides for any orders that match the provided position side in the Margin Strategy.

Checks if a strategy has orders.

hasorders(s::Strategies.Strategy) -> Any

Checks if an asset instance has a specific order in a strategy by side.

hasorders(s::Strategies.Strategy, ai, id::String) -> Bool
hasorders(
    s::Strategies.Strategy,
    ai,
    id::String,
    ::Union{Type{S<:OrderTypes.OrderSide}, Type{<:OrderTypes.Order{<:OrderTypes.OrderType{S<:OrderTypes.OrderSide}}}, OrderTypes.Order{<:OrderTypes.OrderType{S<:OrderTypes.OrderSide}}, OrderTypes.Trade{<:OrderTypes.OrderType{S<:OrderTypes.OrderSide}}, S<:OrderTypes.OrderSide}
) -> Bool

Checks if an asset instance has pending buy orders in a strategy.

hasorders(
    s::Strategies.Strategy,
    ai,
    _::Type{S<:Union{OrderTypes.Buy, OrderTypes.Sell}}
) -> Bool

Checks if a strategy has sell orders.

hasorders(
    s::Strategies.Strategy,
    _::Union{Type{S<:OrderTypes.OrderSide}, Type{<:OrderTypes.Order{<:OrderTypes.OrderType{S<:OrderTypes.OrderSide}}}, OrderTypes.Order{<:OrderTypes.OrderType{S<:OrderTypes.OrderSide}}, OrderTypes.Trade{<:OrderTypes.OrderType{S<:OrderTypes.OrderSide}}, S<:OrderTypes.OrderSide}
) -> Bool

More precise version of hastrade.

Check if the given trade is in the order.

hastrade(o::OrderTypes.Order, t::OrderTypes.Trade) -> Bool

When an increase order is added to a strategy, the asset is added to the holdings.

hold!(
    s::Strategies.Strategy,
    ai,
    o::OrderTypes.IncreaseOrder
) -> Set{Instances.AssetInstance{T, E} where T<:AbstractAsset} where E<:ExchangeID

Reduce orders can never switch an asset from not held to held.

hold!(_::Strategies.Strategy, _, _::OrderTypes.ReduceOrder)

Checks if an increase order can be committed to a strategy.

iscommittable(
    s::Strategies.Strategy,
    o::OrderTypes.IncreaseOrder,
    ai
) -> Any

Checks if a short buy order can be committed to an asset instance.

iscommittable(
    _::Strategies.Strategy,
    o::OrderTypes.Order{<:OrderTypes.OrderType{OrderTypes.Buy}, A, E, Misc.Short} where {A, E},
    ai
) -> Any

Checks if a sell order can be committed to an asset instance.

iscommittable(
    _::Strategies.Strategy,
    o::OrderTypes.Order{<:OrderTypes.OrderType{OrderTypes.Sell}, A, E, Misc.Long} where {A, E},
    ai
) -> Any

Checks if a strategy can commit to an increase order.

iscommittable(
    s::Strategies.Strategy,
    _::Type{<:OrderTypes.IncreaseOrder},
    commit,
    ai
) -> Any

Checks if a strategy can commit to a short buy order.

iscommittable(
    _::Strategies.Strategy,
    _::Type{<:OrderTypes.Order{<:OrderTypes.OrderType{OrderTypes.Buy}, A, E, Misc.Short} where {A, E}},
    commit,
    ai
) -> Any

Checks if a strategy can commit to a sell order.

iscommittable(
    s::Strategies.Strategy,
    _::Type{<:OrderTypes.Order{<:OrderTypes.OrderType{OrderTypes.Sell}, A, E, Misc.Long} where {A, E}},
    commit,
    ai
) -> Any

Checks if an order is filled.

isfilled(
    ai::Instances.AssetInstance,
    o::OrderTypes.Order
) -> Any

Checks if the provided trade is the first fill for the given asset instance.

isfirstfill(
    _::Instances.AssetInstance,
    t::OrderTypes.Trade{<:OrderTypes.LimitOrderType}
) -> Any

Checks if the provided trade is the last fill for the given asset instance.

islastfill(
    ai::Instances.AssetInstance,
    t::OrderTypes.Trade{<:OrderTypes.LimitOrderType}
) -> Any

Tests if a position should be liquidated at a particular price.

isliquidatable(
    _::Strategies.RTStrategy,
    ai::Instances.AssetInstance{<:AbstractAsset, <:ExchangeID, M} where M<:Misc.WithMargin,
    p::Misc.PositionSide,
    date::Dates.DateTime
) -> Any

This function checks whether a position in a Paper or Live strategy should be liquidated at the current price at the specified date.

Checks if a position is liquidatable at a given date

isliquidatable(
    _::Strategies.SimStrategy,
    ai::Instances.AssetInstance{<:AbstractAsset, <:ExchangeID, M} where M<:Misc.WithMargin,
    p::Misc.PositionSide,
    date::Dates.DateTime
) -> Any

This function determines whether a position in a margin strategy is eligible for liquidation at the specified date.

Checks if a strategy is out of orders.

isoutof_orders(s::Strategies.Strategy) -> Any

Checks if an order is already added to the queue.

isqueued(
    o::OrderTypes.Order{<:OrderTypes.OrderType{S<:OrderTypes.OrderSide}},
    s::Strategies.Strategy,
    ai
) -> Any

Places a limit order in the strategy

limitorder(
    s::Strategies.Strategy,
    ai,
    amount;
    date,
    type,
    price,
    take,
    stop,
    skipcommit,
    kwargs...
)

This function places a limit order with specified parameters in the strategy s. The type argument specifies the type of the order. The price defaults to the current price at the given date if not provided. The take and stop arguments are optional and default to nothing. If skipcommit is true, the function will not commit the order. Additional arguments can be passed via kwargs.

The number of liquidations that have happened for an asset instance.

liquidations(
    ai::Instances.AssetInstance{<:AbstractAsset, <:ExchangeID, M} where M<:Misc.WithMargin
) -> @NamedTuple{long::Vector{OrderTypes.Trade}, long_loss::Float64, short::Vector{OrderTypes.Trade}, short_loss::Float64}

This function counts the number of liquidations that have occurred in the history of a margin asset instance.

Returns a generator for long orders matching a given order side

longorders(
    s::Strategies.Strategy,
    ai,
    os::Type{<:OrderTypes.OrderSide}
) -> Base.Generator{I, typeof(identity)} where I<:(Base.Iterators.Filter{Executors.var"#94#95"{Misc.Long}})

This function utilizes the orders function to generate orders for the Long position side that match the provided order side.

Executes a market order.

marketorder(
    s::Strategies.Strategy,
    ai,
    amount;
    date,
    type,
    take,
    stop,
    price,
    skipcommit,
    kwargs...
)

This function takes a strategy, an ai, an amount, and other optional arguments such as date, type, take, stop, price, and kwargs. It executes a market order with the given parameters. If skipcommit is set to false (default), the order is committed. Returns nothing.

Returns the order that matches the given id (if any).

order_byid(
    s::Strategies.Strategy,
    ai::Instances.AssetInstance,
    id::String
) -> Any

Returns all orders for an asset instance in a strategy.

orders(s, ai, _::Type{OrderTypes.BuyOrSell}) -> Any

Returns a generator for orders matching a given position side and order side

orders(
    s::Strategies.Strategy,
    ai,
    pos::Misc.PositionSide,
    os::Type{<:OrderTypes.OrderSide}
) -> Base.Generator{I, typeof(identity)} where I<:(Base.Iterators.Filter{F} where F<:(Executors.var"#94#95"{<:Misc.PositionSide}))

This function iterates over the orders of a strategy, returning only those that match the provided position side and order side.

Returns a generator for orders matching a given position side

orders(
    s::Strategies.Strategy,
    ai,
    pos::Misc.PositionSide
) -> Base.Iterators.Flatten{I} where I<:(Base.Generator{Tuple{DataType, DataType}, F} where F<:(Executors.var"#96#97"{Strategies.Strategy{X, N, E, M, C}, _A, <:Misc.PositionSide} where {X<:Misc.ExecMode, N, E<:ExchangeID, M<:Misc.MarginMode, C, _A}))

This function iterates over the orders of a strategy for both Buy and Sell sides, returning those that match the provided position side.

Iterates over all the orderless orders for an asset instance in a strategy.

orders(
    s::Strategies.Strategy,
    ai::Instances.AssetInstance,
    _::Val{:orderless}
) -> Base.Iterators.Flatten{I} where I<:(Base.Generator{Tuple{DataType, DataType}, F} where F<:(Executors.var"#50#51"{Strategies.Strategy{X, N, E, M, C}, Instances.AssetInstance{T, E1, M1}} where {X<:Misc.ExecMode, N, E<:ExchangeID, M<:Misc.MarginMode, C, T<:AbstractAsset, E1<:ExchangeID, M1<:Misc.MarginMode}))

Iterates over all the orders for an asset instance in a strategy.

orders(
    s::Strategies.Strategy,
    ai::Instances.AssetInstance
) -> Union{Executors.OrderIterator, SortedDict{@NamedTuple{price::Float64, time::Dates.DateTime}, D, Strategies.BuyPriceTimeOrdering} where D<:(OrderTypes.AnyBuyOrder{P, T, E} where {E<:ExchangeID, P<:Misc.PositionSide, T<:AbstractAsset}), SortedDict{@NamedTuple{price::Float64, time::Dates.DateTime}, D, Strategies.SellPriceTimeOrdering} where D<:(OrderTypes.AnySellOrder{P, T, E} where {E<:ExchangeID, P<:Misc.PositionSide, T<:AbstractAsset})}

Returns all buy orders for a strategy.

orders(
    s::Strategies.Strategy,
    _::Union{Type{OrderTypes.Buy}, OrderTypes.Buy, Type{<:OrderTypes.AnyBuyOrder{P, A, E, var"#s237"} where {var"#s237"<:OrderTypes.OrderType{OrderTypes.Buy}, A<:AbstractAsset, E<:ExchangeID, P<:Misc.PositionSide}}, OrderTypes.Trade{<:OrderTypes.OrderType{OrderTypes.Buy}}, OrderTypes.AnyBuyOrder{P, A, E} where {P<:Misc.PositionSide, A<:AbstractAsset, E<:ExchangeID}}
) -> Executors.OrderIterator

Returns all sell orders for a strategy.

orders(
    s::Strategies.Strategy,
    _::Union{Type{OrderTypes.Sell}, OrderTypes.Sell, Type{<:OrderTypes.AnySellOrder{P, A, E, var"#s237"} where {var"#s237"<:OrderTypes.OrderType{OrderTypes.Sell}, A<:AbstractAsset, E<:ExchangeID, P<:Misc.PositionSide}}, OrderTypes.Trade{<:OrderTypes.OrderType{OrderTypes.Sell}}, OrderTypes.AnySellOrder{P, A, E} where {P<:Misc.PositionSide, A<:AbstractAsset, E<:ExchangeID}}
) -> Executors.OrderIterator

Iterates orderlessly over all the orders in a strategy (all the assets in the universe).

orders(
    s::Strategies.Strategy,
    _::Val{:orderless},
    _::Val{:universe}
) -> Executors.OrderIterator

Iterates over all the orderless orders in a strategy.

orders(
    s::Strategies.Strategy,
    _::Val{:orderless}
) -> Base.Iterators.Flatten{I} where I<:(Base.Generator{Tuple{DataType, DataType}, F} where F<:(Executors.var"#37#38"{Strategies.Strategy{X, N, E, M, C}} where {X<:Misc.ExecMode, N, E<:ExchangeID, M<:Misc.MarginMode, C}))

Iterates over all the orders in a strategy (all the assets in the universe).

orders(
    s::Strategies.Strategy,
    _::Val{:universe}
) -> Executors.OrderIterator

Iterates over all the orders in a strategy.

orders(s::Strategies.Strategy) -> Executors.OrderIterator

Returns all buy orders for an asset in a strategy.

orders(
    s::Strategies.Strategy{M, S, E},
    ai,
    _::Union{Type{OrderTypes.Buy}, OrderTypes.Buy, Type{<:OrderTypes.AnyBuyOrder{P, A, E, var"#s237"} where {var"#s237"<:OrderTypes.OrderType{OrderTypes.Buy}, A<:AbstractAsset, E<:ExchangeID, P<:Misc.PositionSide}}, OrderTypes.Trade{<:OrderTypes.OrderType{OrderTypes.Buy}}, OrderTypes.AnyBuyOrder{P, A, E} where {P<:Misc.PositionSide, A<:AbstractAsset, E<:ExchangeID}}
) -> SortedDict{@NamedTuple{price::Float64, time::Dates.DateTime}, D, Strategies.BuyPriceTimeOrdering} where D<:(OrderTypes.AnyBuyOrder{P, T, _A} where {_A, P<:Misc.PositionSide, T<:AbstractAsset})

Returns all sell orders for an asset in a strategy.

orders(
    s::Strategies.Strategy{M, S, E},
    ai,
    _::Union{Type{OrderTypes.Sell}, OrderTypes.Sell, Type{<:OrderTypes.AnySellOrder{P, A, E, var"#s237"} where {var"#s237"<:OrderTypes.OrderType{OrderTypes.Sell}, A<:AbstractAsset, E<:ExchangeID, P<:Misc.PositionSide}}, OrderTypes.Trade{<:OrderTypes.OrderType{OrderTypes.Sell}}, OrderTypes.AnySellOrder{P, A, E} where {P<:Misc.PositionSide, A<:AbstractAsset, E<:ExchangeID}}
) -> SortedDict{@NamedTuple{price::Float64, time::Dates.DateTime}, D, Strategies.SellPriceTimeOrdering} where D<:(OrderTypes.AnySellOrder{P, T, _A} where {_A, P<:Misc.PositionSide, T<:AbstractAsset})

Returns the count of orders for an asset in a strategy.

orderscount(
    s::Strategies.Strategy,
    ai::Instances.AssetInstance,
    _::Type{OrderTypes.BuyOrSell}
) -> Any

Returns the count of buy orders for an asset in a strategy.

orderscount(
    s::Strategies.Strategy,
    ai::Instances.AssetInstance,
    _::Type{OrderTypes.Buy}
) -> Int64

Returns the count of sell orders for an asset in a strategy.

orderscount(
    s::Strategies.Strategy,
    ai::Instances.AssetInstance,
    _::Type{OrderTypes.Sell}
) -> Int64

Returns the count of orders for an asset in a strategy.

orderscount(
    s::Strategies.Strategy,
    ai::Instances.AssetInstance
) -> Any

Returns the count of pending entry orders in a strategy.

orderscount(
    s::Strategies.Strategy,
    _::Val{:increase}
) -> Any

Returns the count of pending exit orders in a strategy.

orderscount(s::Strategies.Strategy, _::Val{:reduce}) -> Any

Returns the total count of pending orders in a strategy.

orderscount(s::Strategies.Strategy) -> Any

Returns the count of orders in a strategy.

orderscount(
    s::Strategies.Strategy,
    _::Union{Type{O}, Type{<:OrderTypes.Order{<:OrderTypes.OrderType{O}}}, OrderTypes.Order{<:OrderTypes.OrderType{O}}, OrderTypes.Trade{<:OrderTypes.OrderType{O}}, O}
) -> Tuple{Any, Any}

Returns a unique list of orders from the trade history of a given asset instance.

ordershistory(ai::Instances.AssetInstance) -> Any

Updates the position of the isolated strategy to the given position side at the specified date

position!(
    s::Strategies.IsolatedStrategy,
    ai,
    date::Dates.DateTime,
    p::Misc.PositionSide
) -> Any

This function updates the position of the strategy for the asset in question at the given date to the provided position side.

Non margin strategies don't have positions.

The price for an order at a particular date.

priceat(
    _::Strategies.Strategy,
    _::Type{<:OrderTypes.Order},
    ai,
    date
) -> Any

Adds a limit order to the pending orders of the strategy.

queue!(
    s::Strategies.Strategy,
    o::OrderTypes.Order{<:OrderTypes.LimitOrderType{S<:OrderTypes.OrderSide}},
    ai;
    skipcommit
) -> Bool

This function takes a strategy, a limit order of type LimitOrderType{S}, and an asset instance as arguments. It adds the limit order to the pending orders of the strategy. If skipcommit is set to false (default), the order is committed and held. Returns true if the order was successfully added, otherwise false.

An asset is released when there are no orders for it and its balance is zero.

release!(
    s::Strategies.Strategy,
    ai
) -> Union{Nothing, Set{Instances.AssetInstance{T, E} where T<:AbstractAsset} where E<:ExchangeID}

Returns sell orders for an asset in a strategy.

sellorders(
    s::Strategies.Strategy,
    ai
) -> SortedDict{@NamedTuple{price::Float64, time::Dates.DateTime}, D, Strategies.SellPriceTimeOrdering} where D<:(OrderTypes.AnySellOrder{P, T, E} where {E<:ExchangeID, P<:Misc.PositionSide, T<:AbstractAsset})

Returns a generator for short orders matching a given order side

shortorders(
    s::Strategies.Strategy,
    ai,
    os::Type{<:OrderTypes.OrderSide}
) -> Base.Generator{I, typeof(identity)} where I<:(Base.Iterators.Filter{Executors.var"#94#95"{Misc.Short}})

This function utilizes the orders function to generate orders for the Short position side that match the provided order side.

Returns orders for an asset in a strategy by side.

sideorders(
    s::Strategies.Strategy,
    ai,
    _::Type{OrderTypes.Buy}
) -> SortedDict{@NamedTuple{price::Float64, time::Dates.DateTime}, D, Strategies.BuyPriceTimeOrdering} where D<:(OrderTypes.AnyBuyOrder{P, T, E} where {E<:ExchangeID, P<:Misc.PositionSide, T<:AbstractAsset})

Returns orders for an asset in a strategy by side.

sideorders(
    s::Strategies.Strategy,
    ai,
    _::Type{OrderTypes.Sell}
) -> SortedDict{@NamedTuple{price::Float64, time::Dates.DateTime}, D, Strategies.SellPriceTimeOrdering} where D<:(OrderTypes.AnySellOrder{P, T, E} where {E<:ExchangeID, P<:Misc.PositionSide, T<:AbstractAsset})

Returns orders for an asset in a strategy by side.

sideorders(
    s::Strategies.Strategy,
    ai,
    _::Union{Type{S}, Type{<:OrderTypes.Order{<:OrderTypes.OrderType{S}}}, OrderTypes.Order{<:OrderTypes.OrderType{S}}, OrderTypes.Trade{<:OrderTypes.OrderType{S}}, S}
) -> SortedDict{@NamedTuple{price::Float64, time::Dates.DateTime}, D, Strategies.SellPriceTimeOrdering} where D<:(OrderTypes.AnySellOrder{P, T, E} where {E<:ExchangeID, P<:Misc.PositionSide, T<:AbstractAsset})

Updates the strategy's cash after an increase trade.

strategycash!(
    s::Strategies.IsolatedStrategy,
    ai,
    t::OrderTypes.IncreaseTrade
)

Updates the strategy's cash after a reduce trade.

strategycash!(
    s::Strategies.IsolatedStrategy,
    ai,
    t::OrderTypes.ReduceTrade
)

Updates the strategy's cash after a buy trade.

strategycash!(
    s::Strategies.Strategy{X, N, <:ExchangeID, NoMargin, C} where {X<:Misc.ExecMode, N, C},
    ai,
    t::OrderTypes.BuyTrade
)

Updates the strategy's cash after a sell trade.

strategycash!(
    s::Strategies.Strategy{X, N, <:ExchangeID, NoMargin, C} where {X<:Misc.ExecMode, N, C},
    _,
    t::OrderTypes.SellTrade
)

Executes a trade with the given parameters and updates the strategy state.

trade!(
    s::Strategies.Strategy,
    o,
    ai;
    date,
    price,
    actual_amount,
    fees,
    slippage,
    kwargs...
)

This function executes a trade based on the given order and asset instance. It calculates the actual price, creates a trade using the maketrade function, and updates the strategy and asset instance. If the trade cannot be executed (e.g., not enough cash), the function updates the state as if the order was filled without creating a trade. The function returns the created trade or nothing if the trade could not be executed.

Returns the absolute value of the unfilled amount of an order.

unfilled(o::OrderTypes.Order) -> Any

Calculates the unfulfilled amount for an order.

unfillment(o::OrderTypes.Order) -> Float64

Calculates the unfulfilled amount for a buy order.

unfillment(t::Type{<:OrderTypes.AnyBuyOrder}, amount) -> Any

Calculates the unfulfilled amount for a sell order.

unfillment(
    t::Type{<:OrderTypes.AnySellOrder},
    amount
) -> Any

Updates leverage based on position state.

Updates leverage based on position state.

update_maintenance!(po::Instances.Position; ntl, mmr) -> Any

This function updates the leverage of a position based on its current state, using the provided leverage, price, and maintenance margin ratio.

Updates notional value.

update_notional!(po::Instances.Position; ntl, size)

This function updates the notional value of a position using the provided notional amount and size.

Update the entry price from notional, amount diff and cash.

update_price!(po::Instances.Position; ntl, prev_ntl, size)

This function calculates the new entry price of a position using the notional amount, the difference in amount, and the cash in the position.

Update position price, notional and leverage from a new trade.

withtrade!(
    po::Instances.Position{P},
    t::OrderTypes.Trade{O, A, E, P} where {O<:OrderTypes.OrderType, A<:AbstractAsset, E<:ExchangeID};
    settle_price
) -> Any

This function adjusts the price, notional value, and leverage of a position based on a new trade at the given settlement price.

Returns the committed amount of a short buy order.

committed(
    o::OrderTypes.Order{<:OrderTypes.OrderType{OrderTypes.Buy}, var"#s237", var"#s236", Misc.Short} where {var"#s237"<:AbstractAsset, var"#s236"<:ExchangeID}
) -> Any

Returns the committed amount of an order.

committed(o::OrderTypes.Order) -> Any

Calculates the committed amount for a given position

committed(
    s::Strategies.Strategy{X, N, <:ExchangeID, <:Misc.WithMargin, C} where {X<:Misc.ExecMode, N, C},
    ai::Instances.AssetInstance{<:AbstractAsset, <:ExchangeID, M} where M<:Misc.WithMargin,
    _::Union{Type{P}, Type{O} where O<:(OrderTypes.Order{<:OrderTypes.OrderType, <:AbstractAsset, <:ExchangeID, P}), Type{T} where T<:(OrderTypes.Trade{<:OrderTypes.OrderType, <:AbstractAsset, <:ExchangeID, P}), OrderTypes.Order{<:OrderTypes.OrderType, <:AbstractAsset, <:ExchangeID, P}, OrderTypes.Trade{<:OrderTypes.OrderType, <:AbstractAsset, <:ExchangeID, P}, P}
) -> Float64

This function sums the amounts of all the orders that match the given position in the Margin Strategy.

Checks if the order committed value is below minimum quantity.

isdust(
    ai::Instances.AssetInstance,
    o::OrderTypes.Order
) -> Bool

Calculates the liquidation price of a position

liqprice(
    p::Misc.PositionSide,
    entryprice,
    leverage,
    mmr;
    additional,
    notional
) -> Any

This function calculates the price at which a position would be liquidated, given the entry price, leverage, maintenance margin ratio, additional margin, and notional value.

Updates the strategy's and asset instance's cash after a trade.

cash!(s::Strategies.Strategy, ai, t::OrderTypes.Trade)

Returns the attribute of an order.

attr(o::OrderTypes.Order, sym) -> Any

Resets an order committment and unfilled amount.

reset!(o::OrderTypes.Order, ai) -> Float64

Commits an increase order to a strategy.

commit!(
    s::Strategies.Strategy,
    o::OrderTypes.IncreaseOrder,
    _
)

Commits a reduce order to an asset instance.

commit!(
    _::Strategies.Strategy,
    o::OrderTypes.ReduceOrder,
    ai
) -> Any

Returns the trades of an order.

trades(o::OrderTypes.Order) -> Any

Ensures the amount is within correct boundaries.

Ensures the price is within correct boundaries.