def lay_arb_info(sel1, sel2): """Get lay arb info""" # get the market name and print it out: mark1 = database.DBMaster().ReturnMarkets('SELECT * FROM markets WHERE market_id = ?', (s1.mid,))[0] mark2 = database.DBMaster().ReturnMarkets('SELECT * FROM markets WHERE market_id = ?', (s2.mid,))[0] print mark1.name print mark2.name print olay, s1.name, s1.exid, oback
def __init__(self): # key to match_cache is event name, value is list of tuples # (m1, m2) where m1 and m2 are the matching markets (m1 is the # BDAQ market, m2 is the BF market. The ordering of the # tuples is the same as the ordering that appears in the GUI. self._match_cache = {} # store a dict that maps BDAQ mids to BF mids self._BDAQmap_cache = {} # and a dict that maps BF mids to BDAQ mids self._BFmap_cache = {} # and a dict that maps BDAQ mids to their market objects self._BDAQ_cache = {} # and a dict that maps BF mids to their market objects self._BF_cache = {} # singleton that controls DB access self._dbman = database.DBMaster() if self.INITDB: self.init_caches_from_DB() else: self.init_caches_empty()
def __init__(self): # matching selections keys are bdaqmid, values are # [(bdaq_sels, bf_sels)] where bdaq_sels and bf_sels are lists # of bdaq and bf selections, ordered as displayed on the BDAQ # website. Instead of dumping everything from the DB into the # cache immediately, we add to the cache 'as needed'. self._match_cache = {} # map a BF sid to a BDAQ sid; note this has an additional # layer compared to the BDAQ cache since we must store the # market id. self._BFmap_cache = {} # map a BDAQ sid to selection object. Note: we do not have an # equivalent cache for BF sid's since these do not map # uniquely onto selections (an annoying feature of the BF # API). That is, we need both the BF mid and sid to map to a # BDAQ sid. self._BDAQ_cache = {} # we need to access the market store since when we add # matching selections, we need to find the BF mid that matches # the given BDAQ mid. self._mstore = MatchMarketStore.Instance() # singleton that controls DB access self._dbman = database.DBMaster() if self.INITDB: self.init_caches_from_DB()
def save_strategies(bdaqids=[], instantonly=True): """ Using info in the DB, get strategies and save these to pickle file. bdaqids - list of BDAQ market ids allowed. If empty, all market ids are allowed. """ sgroup = strategy.StrategyGroup() # add strategies here msels = database.DBMaster().ReturnSelectionMatches(bdaqids) if bdaqids: # filter out any strategies not involving one of the markets # listed in bdaqids for ms in list(msels): if ms[0].mid not in bdaqids: msels.remove(ms) # alter the prices so that we get instant opp!! #msels[0][0].backprices[0] = (1.50, 10) #msels[0][1].layprices[0] = (1.01, 10) for m in msels: sgroup.add(cxstrategy.CXStrategy(m[0], m[1], instantonly)) betlog.betlog.debug("Created {0} strategies from DB"\ .format(len(sgroup))) # pickle the strategy group - the main application will read this # pickle file. pickle_stratgroup(sgroup) return
def __init__(self): """Class for storing latest prices.""" # current state of prices self._prices = {const.BDAQID: {}, const.BFID: {}} # note newprices is not 'private' since it is accessed by the # engine; it will be fed to the strategies. self.newprices = {const.BDAQID: {}, const.BFID: {}} # for writing to database self._dbman = database.DBMaster()
def unpickle_stratgroup(): """Return StrategyGroup object from pickle file.""" f = open(PICKPATH, 'rb') sgroup = pickle.load(f) f.close() # this initialises cursor object for s in sgroup.strategies: if hasattr(s, 'dbman'): s.dbman = database.DBMaster() return sgroup
def __init__(self): # the current state of all orders placed since the start of # the application. The keys to each sub-dictionary are the # order ids, with values that are the order objects. Note each # order object will typically be updated multiple times. self._orders = {const.BDAQID: {}, const.BFID: {}} # the state of all orders immediately after they were placed. # Among other things, these order objects are useful since # they have a 'tplaced' attribute. self._neworders = {const.BDAQID: {}, const.BFID: {}} # store mapping of order ref to time placed. self._tplaced = {const.BDAQID: {}, const.BFID: {}} # the state of all orders immediately after they were placed. self._cancelorders = {const.BDAQID: {}, const.BFID: {}} # for writing to database self._dbman = database.DBMaster() # store dicts of cancelled, updated and new orders placed by # the APIs from the latest tick. self.latest = [{ const.BDAQID: {}, const.BFID: {} }, { const.BDAQID: {}, const.BFID: {} }, { const.BDAQID: {}, const.BFID: {} }] # store dict of updated orders from last tick (from querying # order status via the API). self.latest_updates = {const.BDAQID: {}, const.BFID: {}} # store dict used by strategies to seach for order references # immediately after order placed. Since we get the order # reference when placing bets on BF, we write to this when # placing bets. But when placing bets on BDAQ, we don't get # the order reference, so instead this is written when we call # ListOrdersChangedSince. self.orders_tosearch = {const.BDAQID: {}, const.BFID: {}}
def __init__(self, ex1sel=None, ex2sel=None, instantonly=True): """ ex1sel - BDAQ selection ex2sel - BF selection instantonly - if True, only look for 'instant' opportunities. This means only 'taking' and not 'making'. """ # this gives us self.brain, a StateMachine, and self.toplace, # a dictionary of orders waiting to be placed (see # strategy.py). super(CXStrategy, self).__init__() self.sel1 = ex1sel self.sel2 = ex2sel # if this is true, we will only look for 'instant' # opportunities, when we can back and lay simultaneously. self.ionly = instantonly # database interface self.dbman = database.DBMaster() # add states noopp_state = CXStateNoOpp(self) instantopp_state = CXStateInstantOpp(self) opp_state = CXStateOpp(self) lay_placed_state = CXStateLayPlaced(self) back_placed_state = CXStateLayPlaced(self) both_placed_state = CXStateBothPlaced(self) lay_matched_state = CXStateLayMatched(self) back_matched_state = CXStateBackMatched(self) both_matched_state = CXStateBothMatched(self) self.brain.add_state(noopp_state) self.brain.add_state(instantopp_state) self.brain.add_state(opp_state) self.brain.add_state(lay_placed_state) self.brain.add_state(back_placed_state) self.brain.add_state(both_placed_state) self.brain.add_state(lay_matched_state) self.brain.add_state(back_matched_state) self.brain.add_state(both_matched_state) # initialise into noopp state self.brain.set_state(noopp_state.name)
def __init__(self, deltat): """deltat is time between price refreshes in seconds.""" self.clock = betman.all.clock.Clock(deltat) self.dbman = database.DBMaster() self.load_strategies() # market ids for all strategies (for updating prices) self.marketids = self.stratgroup.get_marketids() # we store selection objects as a dictionary of dictionaries. # This contains the selection objects (e.g. a particular # horse), and the selection objects contain the current price, # hence the name. self.prices = {const.BDAQID: {}, const.BFID: {}} # orders for both exchanges self.orders = {const.BDAQID: {}, const.BFID: {}} # call the API functions to refresh prices etc. self.on_startup()
import matplotlib.pyplot as plt from betman import database dbman = database.DBMaster() mms = dbman.return_market_matches() bdaqmids = [m[0].id for m in mms] # load all time series data for all runners in both markets (last pair only). mymid = 4028996 # get all selection matches for this mid smatches = dbman.return_selection_matches([mymid]) fig1 = plt.figure() fig2 = plt.figure() ax1 = fig1.add_subplot(111) ax2 = fig2.add_subplot(111) for (s1, s2) in zip(smatches[0], smatches[1]): # time series data from betdaq pdata = dbman.return_selections( 'select * from histselections where exchange_id = ? ' 'and market_id = ? and selection_id = ?', (s2.exid, s2.mid, s2.id)) # back price line, = ax1.plot_date([p.tstamp for p in pdata], [p.padback[0][0] for p in pdata], fmt='-') col = line.get_color() # lay price ax1.plot_date([p.tstamp for p in pdata], [p.padlay[0][0] for p in pdata],