def __init__(self,panelFeed, frequency, marketType=bar.Market.STOCK, maxLen=None):
'''
:param panelFeed:
:param resampleTo: resamplebase.Frequency.(MINUT HOUR DAY WEEK MONTH)
:param maxLen:
'''
if not isinstance(panelFeed, baseFeed.PanelFeed):
raise Exception("panelFeed must be a baseFeed.panelFeed instance")
if maxLen is None:
maxLen = panelFeed.maxLen
super(ResampledPanelFeed,self).__init__(panelFeed.getDataSource(), panelFeed.getInstruments(), frequency, maxLen)
self.dataSource = None #reset dataSource
self.market = marketType
self.panelFeed = panelFeed
self.grouper = PanelGrouper(panelFeed)
self.isResampleFeed = True
self.range = None
self.__currentDateTime = np.nan
self.__needUpdateResampleBar = ResampleState.NOTHING
self.__laggedTime = None
self.__nearlyEndingEvent = observer.Event()
self.__updateValuesEvent = observer.Event()
panelFeed.getNewPanelsEvent(priority=panelFeed.EventPriority.RESAMPLE).subscribe(self.__onNewValues)
def __init__(self):
self.__subjects = []
self.__stop = False
self.__startEvent = observer.Event()
self.__idleEvent = observer.Event()
self.__currDateTime = None
self.__gotError = False
def __init__(self, sleepInterval=0.1):
self._sleepInterval = sleepInterval
self.__subjects = []
self.__stop = False
self.__startEvent = observer.Event()
self.__idleEvent = observer.Event()
self.__currDateTime = None
def __init__(self, currency, apiKey, apiSecret, ignoreMultiCurrency=False):
if currency not in ["USD", "AUD", "CAD", "CHF", "CNY", "DKK", "EUR", "GBP", "HKD", "JPY", "NZD", "PLN", "RUB", "SEK", "SGD", "THB", "NOK", "CZK"]:
raise Exception("Invalid currency")
self.__currency = currency
self.__apiKey = apiKey
self.__apiSecret = apiSecret
self.__ignoreMultiCurrency = ignoreMultiCurrency
self.__thread = None
self.__queue = Queue.Queue()
self.__initializationFailed = None
self.__stopped = False
self.__tickerEvent = observer.Event()
self.__tradeEvent = observer.Event()
self.__userOrderEvent = observer.Event()
self.__wsClient = None
self.__enableReconnection = True
# Build papertrading/livetrading objects.
if apiKey is None or apiSecret is None:
self.__paperTrading = True
else:
self.__paperTrading = False
self.__httpClient = httpclient.HTTPClient(apiKey, apiSecret, currency)
def testEmitOrder(self):
handlersData = []
def handler3():
handlersData.append(3)
def handler1():
handlersData.append(1)
def handler2():
handlersData.append(2)
event = observer.Event()
event.subscribe(handler1)
event.subscribe(handler2)
event.subscribe(handler3)
event.emit()
self.assertTrue(handlersData == [1, 2, 3])
handlersData = []
event = observer.Event()
event.subscribe(handler3)
event.subscribe(handler2)
event.subscribe(handler1)
event.emit()
self.assertTrue(handlersData == [3, 2, 1])
def new_init(self, maxLen=None):
super(dataseries.SequenceDataSeries, self).__init__()
maxLen = dataseries.get_checked_max_len(maxLen)
self._SequenceDataSeries__newValueEvent = observer.Event()
self._SequenceDataSeries__values = collections.ListDeque(maxLen)
self._SequenceDataSeries__dateTimes = collections.ListDeque(maxLen)
self.updateValueEvent = observer.Event()
def __init__(self):
self.__thread = None
self.__initializationOk = None
self.__wsClient = None
self.__enableReconnection = False
self.__stopped = False
self.__tradeEvent = observer.Event()
self.__orderBookUpdateEvent = observer.Event()
def __init__(self, maxLen=None):
super(LiveTradeFeed, self).__init__(bar.Frequency.TRADE, maxLen)
self.__barDicts = []
self.registerInstrument(common.INSTRUMENT_TOKEN)
self.__prevTradeDateTime = None
self.__prevTradeDateTimeDupCount = 0
self.__wsclient = None
self.__initializationOk = None
self.__enableReconnection = True
self.__stopped = False
self.__tickerUpdateEvent = observer.Event()
self.__orderBookModificationEvent = observer.Event()
self.__orderBookRemovalEvent = observer.Event()
def __init__(self,
symbol=["XBTUSD"],
resample_frequancy=60,
test=True,
config=None,
api_key=None,
api_secret=None,
maxLen=None):
super(LiveTradeFeed, self).__init__(bar.Frequency.TRADE, maxLen)
self.__barDicts = []
symbol = symbol if isinstance(symbol, list) else symbol.split(',')
for aSymbol in reversed(symbol):
self.registerInstrument(aSymbol)
common.btc_symbol = aSymbol
self.__prevTradeDateTime = None
self.__thread = None
self.__wsClientConnected = False
self.__enableReconnection = True
self.__stopped = False
self.endpoint = "https://testnet.bitmex.com/api/v1" if test else "https://www.bitmex.com/api/v1"
self.__httpClient = None
for _ in range(3):
try:
self.__httpClient = bitmex.bitmex(test=test,
config=config,
api_key=api_key,
api_secret=api_secret)
break
except Exception as e:
common.logger.info("http error: " + str(e))
if self.__httpClient is None:
raise Exception("http error")
self.symbol = symbol
self.api_key = api_key
self.api_secret = api_secret
self.__orderBookUpdateEvent = observer.Event()
self.__onMargin = observer.Event()
self.__onExecution = observer.Event()
self.__onOrder = observer.Event()
self.__onPostition = observer.Event()
self.resample_frequancy = resample_frequancy
if resample_frequancy / 60 >= 60 * 60 * 24:
self.bin_size = '1d'
elif resample_frequancy / 60 >= 60 * 60:
self.bin_size = '1h'
elif resample_frequancy / 60 >= 60 * 5:
self.bin_size = '5m'
else:
self.bin_size = '1m'
def __init__(self, colNames, maxLen=None, dtype=np.float32):
'''
:param maxLen: 默认按列增长,列为时间
:param colNames: 行为codes
'''
self.__dtype = dtype
self.__maxLen = get_checked_max_len(maxLen)
self.__colLen = len(colNames)
self.__cols = np.array(colNames)
self.__dateTimes = collections.ListDeque(self.__maxLen) # rows
self.__values = collections.NumpyPanelDeque(self.__maxLen,
len(colNames),
dtype=dtype)
self.__newValuesEvent = observer.Event()
self.__updateValuesEvent = observer.Event()
def __init__(self, feedDict=None, panelDict=None):
'''
:param feedDict: {lable: panelFeed}
'''
self.feedDict = feedDict if feedDict is not None else {}
self.panelDict = panelDict if panelDict is not None else {}
self.resamples = {} #重采样数据
self.dataSource = {}
self.instruments = None
self.frequency = np.inf
self.maxLen = 0
self.__currentDatetime = None
self.setUseEventDateTimeInLogs(True)
self.synchronizedNextValue = {} # lable : (dateTime, value)
self.isEof = False
self.stopped = False
self.available = None
self.allAvailable = None
self.__panelEvents = collections.OrderedDict({
e: observer.Event()
for e in PanelFeed.EventPriority.getEventsType()
})
for lable, value in self.feedDict.items():
self.attachFeed(lable, value)
for lable, value in self.panelDict.items():
self.attachPanel(lable, value) # 更新sequenceDataPanel
def __init__(self, maxLen=None):
super(SequenceDataSeries, self).__init__()
maxLen = get_checked_max_len(maxLen)
self.__newValueEvent = observer.Event()
self.__values = collection.ListDeque(maxLen)
self.__dateTimes = collection.ListDeque(maxLen)
def __init__(self, maxLen=DEFAULT_MAX_LEN):
if not maxLen > 0:
raise Exception("Invalid maximum length")
self.__newValueEvent = observer.Event()
self.__values = collections.ListDeque(maxLen)
self.__dateTimes = collections.ListDeque(maxLen)
def __init__(self):
self.__netRet = 0
self.__cumRet = 0
self.__lastBars = {} # Last Bar per instrument.
self.__posTrackers = {}
self.__useAdjClose = False
self.__event = observer.Event()
def __init__(self,
consumerKey,
consumerSecret,
accessToken,
accessTokenSecret,
track=[],
follow=[],
languages=[]):
assert isinstance(track, list), "track must be a list"
assert isinstance(follow, list), "follow must be a list"
assert isinstance(languages, list), "languages must be a list"
super(TwitterFeed, self).__init__()
self.__event = observer.Event()
self.__queue = Queue.Queue()
self.__thread = None
self.__running = False
listener = Listener(self.__queue)
auth = tweepy.OAuthHandler(consumerKey, consumerSecret)
auth.set_access_token(accessToken, accessTokenSecret)
self.__stream = tweepy.Stream(auth, listener)
self.__track = track
self.__follow = follow
self.__languages = languages
def __init__(self,
consumerKey,
consumerSecret,
accessToken,
accessTokenSecret,
track=[],
follow=[],
languages=[]):
if type(track) != types.ListType:
raise Exception("track must be a list")
if type(follow) != types.ListType:
raise Exception("follow must be a list")
if type(languages) != types.ListType:
raise Exception("languages must be a list")
self.__event = observer.Event()
self.__queue = Queue.Queue()
self.__thread = None
self.__running = False
listener = Listener(self.__queue)
auth = tweepy.OAuthHandler(consumerKey, consumerSecret)
auth.set_access_token(accessToken, accessTokenSecret)
self.__stream = tweepy.Stream(auth, listener)
self.__track = track
self.__follow = follow
self.__languages = languages
def __init__(self, barFeed, broker):
assert isinstance(barFeed, pyalgotrade.barfeed.BaseBarFeed
), "barFeed is not a subclass of barfeed.BaseBarFeed"
assert isinstance(broker, pyalgotrade.broker.Broker
), "broker is not a subclass of broker.Broker"
self.__barFeed = barFeed
self.__broker = broker
self.__activePositions = set()
self.__orderToPosition = {}
self.__barsProcessedEvent = observer.Event()
self.__analyzers = []
self.__namedAnalyzers = {}
self.__resampledBarFeeds = []
self.__dispatcher = dispatcher.Dispatcher()
self.__broker.getOrderUpdatedEvent().subscribe(self.__onOrderEvent)
self.__barFeed.getNewValuesEvent().subscribe(self.__onBars)
self.__resultCurrency = "USD"
# onStart will be called once all subjects are started.
self.__dispatcher.getStartEvent().subscribe(self.onStart)
self.__dispatcher.getIdleEvent().subscribe(self.__onIdle)
# It is important to dispatch broker events before feed events, specially if we're backtesting.
self.__dispatcher.addSubject(self.__broker)
self.__dispatcher.addSubject(self.__barFeed)
# Initialize logging.
self.__logger = logger.getLogger(BaseStrategy.LOGGER_NAME)
def __init__(self, maxLen):
super(BaseFeed, self).__init__()
maxLen = dataseries.get_checked_max_len(maxLen)
self.__ds = {}
self.__event = observer.Event()
self.__maxLen = maxLen
def __init__(self, superPanel, indexValues, dataValues, name=None):
self.__superPanel = superPanel
self.index = indexValues
self.values = dataValues
self.name = name
self.__superPanel.getNewValuesEvent().subscribe(self.onNewValue)
self.__newValueEvent = observer.Event()
def __init__(self, frequency, maxLen=dataseries.DEFAULT_MAX_LEN):
assert (maxLen == None or maxLen > 0)
self.__ds = {}
self.__defaultInstrument = None
self.__newBarsEvent = observer.Event()
self.__currentBars = None
self.__lastBars = {}
self.__frequency = frequency
self.__maxLen = maxLen
def __init__(self, maxLen=DEFAULT_MAX_LEN):
assert (maxLen == None or maxLen > 0)
self.__newValueEvent = observer.Event()
# I'm not using collections.deque because:
# 1: Random access is slower.
# 2: Slicing is not supported.
self.__values = []
self.__dateTimes = []
self.__maxLen = maxLen
def __init__(self,
dataSource,
instruments,
frequency=bar.Frequency.MINUTE,
maxLen=None):
self.dataSource = dataSource
self.instruments = sorted(instruments)
self.maxLen = maxLen
self.frequency = frequency
self.__currentDatetime = None
self.fields = list(self.dataSource.fields)
self.stopped = False
self.setUseEventDateTimeInLogs(True)
if 'open' in self.fields:
assert instruments == sorted(
instruments), 'OHLCV columns must be sorted!'
self.openPanel = series.SequenceDataPanel(
instruments, self.maxLen, dtype=np.float32) # 定义了一个类
self.highPanel = series.SequenceDataPanel(instruments,
self.maxLen,
dtype=np.float32)
self.lowPanel = series.SequenceDataPanel(instruments,
self.maxLen,
dtype=np.float32)
self.closePanel = series.SequenceDataPanel(instruments,
self.maxLen,
dtype=np.float32)
self.volumePanel = series.SequenceDataPanel(
instruments, self.maxLen)
self.barFeeds = {}
for instrument in instruments:
self.barFeeds[instrument] = BarFeed(
self,
instrument=instrument,
dateTimes=self.closePanel.getDateTimes(),
_open=self.openPanel[instrument],
_high=self.highPanel[instrument],
_low=self.lowPanel[instrument],
_close=self.closePanel[instrument],
volume=self.volumePanel[instrument],
frequency=self.frequency,
maxLen=self.maxLen)
self.fields = list(self.dataSource.fields)
self.extraPanel = {}
for field in self.fields:
if field not in Field.OHLCV:
self.extraPanel[field] = series.SequenceDataPanel(
instruments, maxLen, dtype=np.float32)
self.__panelEvents = collections.OrderedDict(
{e: observer.Event()
for e in self.EventPriority.getEventsType()})
def __init__(self, cash, commission=None):
assert (cash >= 0)
self.__cash = cash
if commission is None:
self.__commission = NoCommission()
else:
self.__commission = commission
self.__orderUpdatedEvent = observer.Event()
def testDuplicateHandlers(self):
def handler1():
handlersData.append(1)
handlersData = []
event = observer.Event()
event.subscribe(handler1)
event.subscribe(handler1)
event.emit()
self.assertTrue(handlersData == [1])
def __init__(self, maxLen=None):
super(LiveTradeFeed, self).__init__(bar.Frequency.TRADE, maxLen)
self.__barDicts = []
self.registerInstrument(common.btc_symbol)
self.__prevTradeDateTime = None
self.__thread = None
self.__initializationOk = None
self.__enableReconnection = True
self.__stopped = False
self.__orderBookUpdateEvent = observer.Event()
def __init__(self, calendarObj, maxLen):
# super(BaseFeed, self).__init__()
maxLen = dataseries.get_checked_max_len(maxLen)
self.__ds = {}
self.__event = observer.Event()
self.__maxLen = maxLen
#lw添加
self.__canlendarObj = calendarObj
def __init__(self, instrument="BTC", currency="USD", maxLen=None):
super(LiveTradeFeed, self).__init__(bar.Frequency.TRADE, maxLen)
self.__barDicts = []
self.registerInstrument(instrument)
self.__prevTradeDateTime = None
self.__thread = None
self.__wsClientConnected = False
self.__enableReconnection = True
self.__stopped = False
self.__instrument = instrument
self.__currency = currency
self.__orderBookUpdateEvent = observer.Event()
def __init__(self, maxLen=dataseries.DEFAULT_MAX_LEN):
if not isinstance(maxLen, int):
raise Exception("Invalid type for maxLen parameter")
barfeed.BaseBarFeed.__init__(self, bar.Frequency.TRADE, maxLen)
self.__barDicts = []
self.registerInstrument(common.btc_symbol)
self.__prevTradeDateTime = None
self.__thread = None
self.__initializationOk = None
self.__enableReconnection = True
self.__stopped = False
self.__orderBookUpdateEvent = observer.Event()
def __init__(self, instruments, maxLen=None):
super(LiveTradeFeed, self).__init__(bar.Frequency.TRADE, maxLen)
self.__tradeBars = []
self.__channels = []
for instrument in instruments:
instrument = build_instrument(instrument)
self.__channels.append(common.instrument_to_channel(instrument))
self.registerDataSeries(instrument)
self.__thread = None
self.__enableReconnection = True
self.__stopped = False
self.__orderBookUpdateEvent = observer.Event()
def __init__(self, bTestID):
self.bTestID = bTestID
self._stoploss_orders = []
self.trade_orders = {} # trade_orders[tradeo.orderID]=tradeo
self.orderPostions = []
# 这玩意用来记录平仓委托，本来trade_orders记录开仓委托就够了，对于止损逻辑
#但是掘金回测这个傻逼玩意，ontrade中拿不到均价，所以只能在委托回报中先拿到，所以这里要存一下。
self.clearOrders = {}
self.stoplossOrderCreatedEvent = observer.Event()
