Python strategy.Strategy方法代碼示例

# 需要導入模塊: import strategy [as 別名]
# 或者: from strategy import Strategy [as 別名]
def __init__(self, instance):
        strategy.Strategy.__init__(self, instance)
        self._waiting = False
        self.bid = 0
        self.ask = 0
        self.simulate = bool(conf['simulate'])
        self.simulate_or_live = 'SIMULATION - ' if self.simulate else 'LIVE - '
        self.base = self.instance.curr_base
        self.quote = self.instance.curr_quote
        self.wallet = False
        self.step_factor = 1 + DISTANCE / 100.0
        self.step_factor_sell = 1 + DISTANCE_SELL / 100.0
        self.temp_halt = False
        self.name = "%s.%s" % (__name__, self.__class__.__name__)
        self.debug("[s]%s%s loaded" % (self.simulate_or_live, self.name))
        self.help()

        # Simulation wallet
        if (self.simulate and not self.instance.wallet) or (self.simulate and self.wallet):
            self.init_simulation_wallet() 

# 需要導入模塊: import strategy [as 別名]
# 或者: from strategy import Strategy [as 別名]
def __init__(self, api):
        strategy.Strategy.__init__(self, api)
        self.signal_debug.connect(api.signal_debug)
        api.signal_keypress.connect(self.slot_keypress)
        # api.signal_strategy_unload.connect(self.slot_before_unload)
        api.signal_ticker.connect(self.slot_tick)
        api.signal_depth.connect(self.slot_depth)
        api.signal_trade.connect(self.slot_trade)
        api.signal_userorder.connect(self.slot_userorder)
        api.orderbook.signal_owns_changed.connect(self.slot_owns_changed)
        api.signal_wallet.connect(self.slot_wallet_changed)
        self.api = api
        self.name = "%s.%s" % (__name__, self.__class__.__name__)
        self.debug("[s]%s%s loaded" % (simulate_or_live, self.name))
        self.debug("[s]Press 'b' to see Buy objective")
        # get existing orders for later decision making
        self.existingorders = []
        for order in self.api.orderbook.owns:
            self.existingorders.append(order.oid) 

# 需要導入模塊: import strategy [as 別名]
# 或者: from strategy import Strategy [as 別名]
def __init__(self, eventQueue, optCallDelta, maxCallDelta, optPutDelta, maxPutDelta, startTime, buyOrSell,
                 underlying, orderQuantity, daysBeforeClose, expCycle=None, optimalDTE=None,
                 minimumDTE=None, roc=None, minDaysToEarnings=None, minCredit=None, profitTargetPercent=None,
                 customManagement=None, maxBidAsk=None, maxMidDev=None, minDaysSinceEarnings=None, minIVR=None,
                 minBuyingPower=None):

        # For arguments that are not supported or don't have implementations, we return an exception to prevent
        # confusion.
        if not roc == None:
            raise NotImplementedError, "Specifying ROC currently not supported."

        if not minDaysToEarnings == None or not minDaysSinceEarnings == None:
            raise NotImplementedError, "Ability to filter out dates with respect to earnings currently not supported."

        if not minIVR == None:
            raise NotImplementedError, "Specifying implied volatility rank currently not implemented / supported."

        self.__eventQueue = eventQueue
        self.__strategy = "strangle"
        self.__optCallDelta = optCallDelta
        self.__maxCallDelta = maxCallDelta
        self.__optPutDelta = optPutDelta
        self.__maxPutDelta = maxPutDelta

        strategy.Strategy.__init__(self, startTime, self.__strategy, buyOrSell, underlying, orderQuantity,
                                   daysBeforeClose, expCycle, optimalDTE, minimumDTE, roc, minDaysToEarnings,
                                   minCredit, profitTargetPercent, customManagement, maxBidAsk, maxMidDev,
                                   minDaysSinceEarnings, minIVR, minBuyingPower) 

# 需要導入模塊: import strategy [as 別名]
# 或者: from strategy import Strategy [as 別名]
def test_default_strategy(self):
        self.assertEqual(Strategy().name, "Strategy_default") 

# 需要導入模塊: import strategy [as 別名]
# 或者: from strategy import Strategy [as 別名]
def test_replacement_strategy_one(self):
        self.assertEqual(
            Strategy(execute_replacement1).name, "Strategy_execute_replacement1"
        ) 

# 需要導入模塊: import strategy [as 別名]
# 或者: from strategy import Strategy [as 別名]
def test_replacement_strategy_two(self):
        self.assertEqual(
            Strategy(execute_replacement2).name, "Strategy_execute_replacement2"
        ) 

# 需要導入模塊: import strategy [as 別名]
# 或者: from strategy import Strategy [as 別名]
def __init__(self):

        # Set False for forward testing.
        self.live_trading = True

        self.log_level = logging.DEBUG
        self.logger = self.setup_logger()

        self.exchanges = self.load_exchanges(self.logger)

        self.db_client = MongoClient(
            self.DB_URL,
            serverSelectionTimeoutMS=self.DB_TIMEOUT_MS)
        self.db_prices = self.db_client[self.DB_PRICES]
        self.db_other = self.db_client[self.DB_OTHER]
        self.check_db_connection()

        # Main event queue.
        self.events = queue.Queue(0)

        # Producer/consumer worker classes.
        self.data = Datahandler(self.exchanges, self.logger, self.db_prices,
                                self.db_client)

        self.strategy = Strategy(self.exchanges, self.logger, self.db_prices,
                                 self.db_other, self.db_client)

        self.portfolio = Portfolio(self.exchanges, self.logger, self.db_other,
                                   self.db_client, self.strategy.models)

        self.broker = Broker(self.exchanges, self.logger, self.portfolio,
                             self.db_other, self.db_client, self.live_trading)

        # Processing performance tracking variables.
        self.start_processing = None
        self.end_processing = None
        self.cycle_count = 0

        self.run()