def __call__(self, side=None):
from marketsim.gen._out.side._sell import Sell_ as _side_Sell_
from marketsim.gen._out.order._curried._price_withexpiry import price_WithExpiry
side = side if side is not None else _side_Sell_()
expiry = self.expiry
proto = self.proto
return price_WithExpiry(expiry, proto(side))
def __call__(self, side=None):
from marketsim.gen._out.side._sell import Sell_ as _side_Sell_
from marketsim.gen._out.order._stoploss import StopLoss
side = side if side is not None else _side_Sell_()
maxloss = self.maxloss
proto = self.proto
return StopLoss(maxloss, proto(side))
def __call__(self, side = None):
from marketsim.gen._out.side._sell import Sell_ as _side_Sell_
from marketsim.gen._out.order._floatingprice import FloatingPrice
side = side if side is not None else _side_Sell_()
floatingPrice = self.floatingPrice
proto = self.proto
return FloatingPrice(floatingPrice, proto(side))
def __init__(self, side=None, volume=None):
from marketsim.gen._out.side._sell import Sell_ as _side_Sell_
from marketsim import deref_opt
from marketsim.gen._out._constant import constant_Float as _constant_Float
self.side = side if side is not None else deref_opt(_side_Sell_())
self.volume = volume if volume is not None else deref_opt(_constant_Float(1.0))
def __init__(self, book = None, side = None):
from marketsim.gen._out.orderbook._oftrader import OfTrader_IAccount as _orderbook_OfTrader_IAccount
from marketsim import deref_opt
from marketsim.gen._out.side._sell import Sell_ as _side_Sell_
self.book = book if book is not None else deref_opt(_orderbook_OfTrader_IAccount())
self.side = side if side is not None else deref_opt(_side_Sell_())
Queue_Impl.__init__(self)
def __call__(self, side = None):
from marketsim.gen._out.side._sell import Sell_ as _side_Sell_
from marketsim.gen._out.order._curried._price_floatingprice import price_FloatingPrice
side = side if side is not None else _side_Sell_()
floatingPrice = self.floatingPrice
proto = self.proto
return price_FloatingPrice(floatingPrice, proto(side))
def __call__(self, side=None):
from marketsim.gen._out.side._sell import Sell_ as _side_Sell_
from marketsim import deref_opt
from marketsim.gen._out.order._peg import Peg
side = side if side is not None else deref_opt(_side_Sell_())
proto = self.proto
return Peg(proto(side))
def __call__(self, side = None):
from marketsim.gen._out.side._sell import Sell_ as _side_Sell_
from marketsim.gen._out.order._withexpiry import WithExpiry
side = side if side is not None else _side_Sell_()
expiry = self.expiry
proto = self.proto
return WithExpiry(expiry, proto(side))
def __init__(self, side = None, volume = None):
from marketsim.gen._out.side._sell import Sell_ as _side_Sell_
from marketsim.gen._out._constant import constant_Float as _constant_Float
from marketsim import rtti
self.side = side if side is not None else _side_Sell_()
self.volume = volume if volume is not None else _constant_Float(1.0)
rtti.check_fields(self)
def __call__(self, side = None):
from marketsim.gen._out.side._sell import Sell_ as _side_Sell_
from marketsim import deref_opt
from marketsim.gen._out.order._curried._price_peg import price_Peg
side = side if side is not None else deref_opt(_side_Sell_())
proto = self.proto
return price_Peg(proto(side))
def getImpl(self):
from marketsim.gen._out.math._exp import Exp_Float as _math_Exp_Float
from marketsim.gen._out.side._buy import Buy_ as _side_Buy_
from marketsim.gen._out.ops._div import Div_IObservableFloatFloat as _ops_Div_IObservableFloatFloat
from marketsim.gen._out.math._atan import Atan_Float as _math_Atan_Float
from marketsim.gen._out._constant import constant_Int as _constant_Int
from marketsim.gen._out.ops._div import Div_FloatFloat as _ops_Div_FloatFloat
from marketsim.gen._out.side._sell import Sell_ as _side_Sell_
from marketsim.gen._out._constant import constant_Float as _constant_Float
from marketsim.gen._out.order._floatingprice import FloatingPrice_IObservableFloatFloatIObservableIOrder as _order_FloatingPrice_IObservableFloatFloatIObservableIOrder
from marketsim.gen._out.observable._breaksatchanges import BreaksAtChanges_IObservableFloat as _observable_BreaksAtChanges_IObservableFloat
from marketsim.gen._out.order._curried._price_limit import price_Limit_SideFloat as _order__curried_price_Limit_SideFloat
from marketsim.gen._out.orderbook._bids import Bids_IOrderBook as _orderbook_Bids_IOrderBook
from marketsim.gen._out.orderbook._safesideprice import SafeSidePrice_IOrderQueueFloat as _orderbook_SafeSidePrice_IOrderQueueFloat
from marketsim.gen._out.strategy._combine import Combine_ISingleAssetStrategyISingleAssetStrategy as _strategy_Combine_ISingleAssetStrategyISingleAssetStrategy
from marketsim.gen._out.observable._oneverydt import OnEveryDt_FloatFloat as _observable_OnEveryDt_FloatFloat
from marketsim.gen._out.event._after import After_Float as _event_After_Float
from marketsim.gen._out.orderbook._asks import Asks_IOrderBook as _orderbook_Asks_IOrderBook
from marketsim.gen._out.strategy._generic import Generic_IObservableIOrderIEvent as _strategy_Generic_IObservableIOrderIEvent
from marketsim.gen._out.trader._position import Position_IAccount as _trader_Position_IAccount
from marketsim.gen._out.order._iceberg import Iceberg_IObservableIOrderFloat as _order_Iceberg_IObservableIOrderFloat
return _strategy_Combine_ISingleAssetStrategyISingleAssetStrategy(
_strategy_Generic_IObservableIOrderIEvent(
_order_Iceberg_IObservableIOrderFloat(
_order_FloatingPrice_IObservableFloatFloatIObservableIOrder(
_observable_BreaksAtChanges_IObservableFloat(
_observable_OnEveryDt_FloatFloat(
_ops_Div_IObservableFloatFloat(
_orderbook_SafeSidePrice_IOrderQueueFloat(
_orderbook_Asks_IOrderBook(),
_constant_Float((100 + self.delta))),
_math_Exp_Float(
_ops_Div_FloatFloat(
_math_Atan_Float(
_trader_Position_IAccount()),
_constant_Int(1000)))), 0.9)),
_order__curried_price_Limit_SideFloat(
_side_Sell_(), _constant_Float(
(self.volume * 1000)))),
_constant_Float(self.volume)),
_event_After_Float(_constant_Float(0.0))),
_strategy_Generic_IObservableIOrderIEvent(
_order_Iceberg_IObservableIOrderFloat(
_order_FloatingPrice_IObservableFloatFloatIObservableIOrder(
_observable_BreaksAtChanges_IObservableFloat(
_observable_OnEveryDt_FloatFloat(
_ops_Div_IObservableFloatFloat(
_orderbook_SafeSidePrice_IOrderQueueFloat(
_orderbook_Bids_IOrderBook(),
_constant_Float((100 - self.delta))),
_math_Exp_Float(
_ops_Div_FloatFloat(
_math_Atan_Float(
_trader_Position_IAccount()),
_constant_Int(1000)))), 0.9)),
_order__curried_price_Limit_SideFloat(
_side_Buy_(), _constant_Float(
(self.volume * 1000)))),
_constant_Float(self.volume)),
_event_After_Float(_constant_Float(0.0))))
def __init__(self, side=None, volume=None):
from marketsim.gen._out.side._sell import Sell_ as _side_Sell_
from marketsim.gen._out._constant import constant_Float as _constant_Float
from marketsim import rtti
self.side = side if side is not None else _side_Sell_()
self.volume = volume if volume is not None else _constant_Float(1.0)
rtti.check_fields(self)
def __call__(self, side = None):
from marketsim.gen._out.side._sell import Sell_ as _side_Sell_
from marketsim.gen._out.order._curried._price_iceberg import price_Iceberg
side = side if side is not None else _side_Sell_()
proto = self.proto
lotSize = self.lotSize
return price_Iceberg(proto(side), lotSize)
def __call__(self, side = None):
from marketsim.gen._out.side._sell import Sell_ as _side_Sell_
from marketsim.gen._out.order._stoploss import StopLoss
side = side if side is not None else _side_Sell_()
maxloss = self.maxloss
proto = self.proto
return StopLoss(maxloss, proto(side))
def __call__(self, side = None):
from marketsim.gen._out.side._sell import Sell_ as _side_Sell_
from marketsim import deref_opt
from marketsim.gen._out.order._curried._price_limit import price_Limit
side = side if side is not None else deref_opt(_side_Sell_())
volume = self.volume
return price_Limit(side, volume)
def __call__(self, side=None):
from marketsim.gen._out.side._sell import Sell_ as _side_Sell_
from marketsim import deref_opt
from marketsim.gen._out.order._curried._price_immediateorcancel import price_ImmediateOrCancel
side = side if side is not None else deref_opt(_side_Sell_())
proto = self.proto
return price_ImmediateOrCancel(proto(side))
def __call__(self, side = None):
from marketsim.gen._out.side._sell import Sell_ as _side_Sell_
from marketsim import deref_opt
from marketsim.gen._out.order._market import Market
side = side if side is not None else deref_opt(_side_Sell_())
volume = self.volume
return Market(side, volume)
def __call__(self, side = None):
from marketsim.gen._out.side._sell import Sell_ as _side_Sell_
from marketsim.gen._out.order._limit import Limit
side = side if side is not None else _side_Sell_()
price = self.price
volume = self.volume
return Limit(side, price, volume)
def __call__(self, side = None):
from marketsim.gen._out.side._sell import Sell_ as _side_Sell_
from marketsim import deref_opt
from marketsim.gen._out.order._curried._price_immediateorcancel import price_ImmediateOrCancel
side = side if side is not None else deref_opt(_side_Sell_())
proto = self.proto
return price_ImmediateOrCancel(proto(side))
def __call__(self, side = None):
from marketsim.gen._out.side._sell import Sell_ as _side_Sell_
from marketsim import deref_opt
from marketsim.gen._out.order._fixedbudget import FixedBudget
side = side if side is not None else deref_opt(_side_Sell_())
budget = self.budget
return FixedBudget(side, budget)
def __init__(self, side=None, volume=None):
from marketsim.gen._out.side._sell import Sell_ as _side_Sell_
from marketsim import deref_opt
from marketsim.gen._out._constant import constant_Float as _constant_Float
self.side = side if side is not None else deref_opt(_side_Sell_())
self.volume = volume if volume is not None else deref_opt(
_constant_Float(1.0))
def __call__(self, side=None):
from marketsim.gen._out.side._sell import Sell_ as _side_Sell_
from marketsim import deref_opt
from marketsim.gen._out.order._iceberg import Iceberg
side = side if side is not None else deref_opt(_side_Sell_())
proto = self.proto
lotSize = self.lotSize
return Iceberg(proto(side), lotSize)
def __call__(self, side=None, volume=None):
from marketsim.gen._out.side._sell import Sell_ as _side_Sell_
from marketsim.gen._out._constant import constant_Float as _constant_Float
from marketsim.gen._out.order._curried._price_immediateorcancel import price_ImmediateOrCancel
side = side if side is not None else _side_Sell_()
volume = volume if volume is not None else _constant_Float(1.0)
proto = self.proto
return price_ImmediateOrCancel(proto(side, volume))
def __call__(self, side=None, volume=None):
from marketsim.gen._out.side._sell import Sell_ as _side_Sell_
from marketsim.gen._out._constant import constant_Float as _constant_Float
from marketsim.gen._out.order._peg import Peg
side = side if side is not None else _side_Sell_()
volume = volume if volume is not None else _constant_Float(1.0)
proto = self.proto
return Peg(proto(side, volume))
def __call__(self, side = None,volume = None):
from marketsim.gen._out.side._sell import Sell_ as _side_Sell_
from marketsim.gen._out._constant import constant_Float as _constant_Float
from marketsim.gen._out.order._limit import Limit
side = side if side is not None else _side_Sell_()
volume = volume if volume is not None else _constant_Float(1.0)
price = self.price
return Limit(side, price, volume)
def __call__(self, side = None):
from marketsim.gen._out.side._sell import Sell_ as _side_Sell_
from marketsim import deref_opt
from marketsim.gen._out.order._floatingprice import FloatingPrice
side = side if side is not None else deref_opt(_side_Sell_())
proto = self.proto
floatingPrice = self.floatingPrice
return FloatingPrice(proto(side), floatingPrice)
def __call__(self, side = None):
from marketsim.gen._out.side._sell import Sell_ as _side_Sell_
from marketsim import deref_opt
from marketsim.gen._out.order._iceberg import Iceberg
side = side if side is not None else deref_opt(_side_Sell_())
proto = self.proto
lotSize = self.lotSize
return Iceberg(proto(side), lotSize)
def __call__(self, side = None):
from marketsim.gen._out.side._sell import Sell_ as _side_Sell_
from marketsim import deref_opt
from marketsim.gen._out.order._withexpiry import WithExpiry
side = side if side is not None else deref_opt(_side_Sell_())
proto = self.proto
expiry = self.expiry
return WithExpiry(proto(side), expiry)
def __init__(self, book=None, side=None):
from marketsim.gen._out.orderbook._oftrader import OfTrader_IAccount as _orderbook_OfTrader_IAccount
from marketsim import deref_opt
from marketsim.gen._out.side._sell import Sell_ as _side_Sell_
self.book = book if book is not None else deref_opt(
_orderbook_OfTrader_IAccount())
self.side = side if side is not None else deref_opt(_side_Sell_())
Queue_Impl.__init__(self)
def __call__(self, side=None, price=None):
from marketsim.gen._out.side._sell import Sell_ as _side_Sell_
from marketsim.gen._out._constant import constant_Float as _constant_Float
from marketsim.gen._out.order._limit import Limit
side = side if side is not None else _side_Sell_()
price = price if price is not None else _constant_Float(100.0)
volume = self.volume
return Limit(side, price, volume)
def __call__(self, side = None):
from marketsim.gen._out.side._sell import Sell_ as _side_Sell_
from marketsim import deref_opt
from marketsim.gen._out.order._stoploss import StopLoss
side = side if side is not None else deref_opt(_side_Sell_())
proto = self.proto
maxloss = self.maxloss
return StopLoss(proto(side), maxloss)
def __call__(self, side = None,volume = None):
from marketsim.gen._out.side._sell import Sell_ as _side_Sell_
from marketsim.gen._out._constant import constant_Float as _constant_Float
from marketsim.gen._out.order._curried._price_peg import price_Peg
side = side if side is not None else _side_Sell_()
volume = volume if volume is not None else _constant_Float(1.0)
proto = self.proto
return price_Peg(proto(side,volume))
def __call__(self, side = None):
from marketsim.gen._out.side._sell import Sell_ as _side_Sell_
from marketsim import deref_opt
from marketsim.gen._out.order._floatingprice import FloatingPrice
side = side if side is not None else deref_opt(_side_Sell_())
proto = self.proto
floatingPrice = self.floatingPrice
return FloatingPrice(proto(side), floatingPrice)
def __call__(self, side=None, volume=None):
from marketsim.gen._out.side._sell import Sell_ as _side_Sell_
from marketsim.gen._out._constant import constant_Float as _constant_Float
from marketsim.gen._out.order._curried._price_limit import price_Limit
side = side if side is not None else _side_Sell_()
volume = volume if volume is not None else _constant_Float(1.0)
return price_Limit(side, volume)
def __init__(self, orderFactory = None, initialSize = None, side = None):
from marketsim.gen._out.order._curried._sideprice_limit import sideprice_Limit_Float as _order__curried_sideprice_Limit_Float
from marketsim import deref_opt
from marketsim.gen._out.side._sell import Sell_ as _side_Sell_
self.orderFactory = orderFactory if orderFactory is not None else deref_opt(_order__curried_sideprice_Limit_Float())
self.initialSize = initialSize if initialSize is not None else 10
self.side = side if side is not None else deref_opt(_side_Sell_())
OneSide_Impl.__init__(self)
def __call__(self, side=None):
from marketsim.gen._out.side._sell import Sell_ as _side_Sell_
from marketsim import deref_opt
from marketsim.gen._out.order._withexpiry import WithExpiry
side = side if side is not None else deref_opt(_side_Sell_())
proto = self.proto
expiry = self.expiry
return WithExpiry(proto(side), expiry)
def __call__(self, side = None,price = None):
from marketsim.gen._out.side._sell import Sell_ as _side_Sell_
from marketsim.gen._out._constant import constant_Float as _constant_Float
from marketsim.gen._out.order._immediateorcancel import ImmediateOrCancel
side = side if side is not None else _side_Sell_()
price = price if price is not None else _constant_Float(100.0)
proto = self.proto
return ImmediateOrCancel(proto(side,price))
def __call__(self, side=None, price=None):
from marketsim.gen._out.side._sell import Sell_ as _side_Sell_
from marketsim.gen._out._constant import constant_Float as _constant_Float
from marketsim.gen._out.order._stoploss import StopLoss
side = side if side is not None else _side_Sell_()
price = price if price is not None else _constant_Float(100.0)
maxloss = self.maxloss
proto = self.proto
return StopLoss(maxloss, proto(side, price))
def __call__(self, side = None,volume = None):
from marketsim.gen._out.side._sell import Sell_ as _side_Sell_
from marketsim.gen._out._constant import constant_Float as _constant_Float
from marketsim.gen._out.order._stoploss import StopLoss
side = side if side is not None else _side_Sell_()
volume = volume if volume is not None else _constant_Float(1.0)
maxloss = self.maxloss
proto = self.proto
return StopLoss(maxloss, proto(side,volume))
def __call__(self, side = None,volume = None):
from marketsim.gen._out.side._sell import Sell_ as _side_Sell_
from marketsim.gen._out._constant import constant_Float as _constant_Float
from marketsim.gen._out.order._floatingprice import FloatingPrice
side = side if side is not None else _side_Sell_()
volume = volume if volume is not None else _constant_Float(1.0)
floatingPrice = self.floatingPrice
proto = self.proto
return FloatingPrice(floatingPrice, proto(side,volume))
def __init__(self, side = None, volume = None):
from marketsim.gen._out.side._sell import Sell_ as _side_Sell_
from marketsim.gen._out._iorder import IOrder
from marketsim.gen._out._constant import constant_Float as _constant_Float
from marketsim.gen._out._observable._observableiorder import ObservableIOrder
from marketsim import deref_opt
ObservableIOrder.__init__(self)
self.side = side if side is not None else deref_opt(_side_Sell_())
self.volume = volume if volume is not None else deref_opt(_constant_Float(1.0))
def __call__(self, side = None,price = None):
from marketsim.gen._out.side._sell import Sell_ as _side_Sell_
from marketsim import deref_opt
from marketsim.gen._out._constant import constant_Float as _constant_Float
from marketsim.gen._out.order._limit import Limit
side = side if side is not None else deref_opt(_side_Sell_())
price = price if price is not None else deref_opt(_constant_Float(100.0))
volume = self.volume
return Limit(side, price, volume)
def __call__(self, side = None,volume = None):
from marketsim.gen._out.side._sell import Sell_ as _side_Sell_
from marketsim.gen._out._constant import constant_Float as _constant_Float
from marketsim.gen._out.order._withexpiry import WithExpiry
side = side if side is not None else _side_Sell_()
volume = volume if volume is not None else _constant_Float(1.0)
expiry = self.expiry
proto = self.proto
return WithExpiry(expiry, proto(side,volume))
def __init__(self, orderFactory=None, initialSize=None, side=None):
from marketsim.gen._out.order._curried._sideprice_limit import sideprice_Limit_Float as _order__curried_sideprice_Limit_Float
from marketsim import deref_opt
from marketsim.gen._out.side._sell import Sell_ as _side_Sell_
self.orderFactory = orderFactory if orderFactory is not None else deref_opt(
_order__curried_sideprice_Limit_Float())
self.initialSize = initialSize if initialSize is not None else 10
self.side = side if side is not None else deref_opt(_side_Sell_())
OneSide_Impl.__init__(self)
def __call__(self, side = None,volume = None):
from marketsim.gen._out.side._sell import Sell_ as _side_Sell_
from marketsim.gen._out._constant import constant_Float as _constant_Float
from marketsim.gen._out.order._curried._price_stoploss import price_StopLoss
side = side if side is not None else _side_Sell_()
volume = volume if volume is not None else _constant_Float(1.0)
maxloss = self.maxloss
proto = self.proto
return price_StopLoss(maxloss, proto(side,volume))
def __call__(self, side=None, price=None):
from marketsim.gen._out.side._sell import Sell_ as _side_Sell_
from marketsim.gen._out._constant import constant_Float as _constant_Float
from marketsim.gen._out.order._iceberg import Iceberg
side = side if side is not None else _side_Sell_()
price = price if price is not None else _constant_Float(100.0)
proto = self.proto
lotSize = self.lotSize
return Iceberg(proto(side, price), lotSize)
def __call__(self, side=None, volume=None):
from marketsim.gen._out.side._sell import Sell_ as _side_Sell_
from marketsim.gen._out._constant import constant_Float as _constant_Float
from marketsim.gen._out.order._curried._price_iceberg import price_Iceberg
side = side if side is not None else _side_Sell_()
volume = volume if volume is not None else _constant_Float(1.0)
proto = self.proto
lotSize = self.lotSize
return price_Iceberg(proto(side, volume), lotSize)
def __call__(self, side=None, volume=None):
from marketsim.gen._out.side._sell import Sell_ as _side_Sell_
from marketsim.gen._out._constant import constant_Float as _constant_Float
from marketsim.gen._out.order._floatingprice import FloatingPrice
side = side if side is not None else _side_Sell_()
volume = volume if volume is not None else _constant_Float(1.0)
floatingPrice = self.floatingPrice
proto = self.proto
return FloatingPrice(floatingPrice, proto(side, volume))
def __call__(self, side = None,price = None):
from marketsim.gen._out.side._sell import Sell_ as _side_Sell_
from marketsim.gen._out._constant import constant_Float as _constant_Float
from marketsim.gen._out.order._iceberg import Iceberg
side = side if side is not None else _side_Sell_()
price = price if price is not None else _constant_Float(100.0)
proto = self.proto
lotSize = self.lotSize
return Iceberg(proto(side,price), lotSize)
def __init__(self, side = None, price = None, volume = None):
from marketsim.gen._out.side._sell import Sell_ as _side_Sell_
from marketsim.gen._out._iorder import IOrder
from marketsim.gen._out._constant import constant_Float as _constant_Float
from marketsim.gen._out._observable._observableiorder import ObservableIOrder
from marketsim import deref_opt
ObservableIOrder.__init__(self)
self.side = side if side is not None else deref_opt(_side_Sell_())
self.price = price if price is not None else deref_opt(_constant_Float(100.0))
self.volume = volume if volume is not None else deref_opt(_constant_Float(1.0))
def __call__(self, side = None,price = None):
from marketsim.gen._out.side._sell import Sell_ as _side_Sell_
from marketsim import deref_opt
from marketsim.gen._out._constant import constant_Float as _constant_Float
from marketsim.gen._out.order._stoploss import StopLoss
side = side if side is not None else deref_opt(_side_Sell_())
price = price if price is not None else deref_opt(_constant_Float(100.0))
proto = self.proto
maxloss = self.maxloss
return StopLoss(proto(side,price), maxloss)
def __call__(self, side = None,price = None):
from marketsim.gen._out.side._sell import Sell_ as _side_Sell_
from marketsim import deref_opt
from marketsim.gen._out._constant import constant_Float as _constant_Float
from marketsim.gen._out.order._withexpiry import WithExpiry
side = side if side is not None else deref_opt(_side_Sell_())
price = price if price is not None else deref_opt(_constant_Float(100.0))
proto = self.proto
expiry = self.expiry
return WithExpiry(proto(side,price), expiry)
def __init__(self, x = None, side = None):
from marketsim.gen._out.side._sell import Sell_ as _side_Sell_
from marketsim import _
from marketsim import event
from marketsim.gen._out._observable._observablefloat import Observablefloat
from marketsim.gen._out.strategy.price._liquidityprovider import LiquidityProvider_FloatFloatIOrderBook as _strategy_price_LiquidityProvider_FloatFloatIOrderBook
from marketsim import deref_opt
Observablefloat.__init__(self)
self.x = x if x is not None else deref_opt(_strategy_price_LiquidityProvider_FloatFloatIOrderBook())
self.side = side if side is not None else deref_opt(_side_Sell_())
self.impl = self.getImpl()
event.subscribe(self.impl, _(self).fire, self)
