import json

from bet356 import getCardCompetitionData, getListCompetition, driver

ITERATION = 50

# connect to API and keep alive session key
dir = os.path.abspath(os.path.dirname(__file__))
key = 'betfair.pem'
out_file_name = 'betfeir.xlsx'
base_dir = os.path.join(dir, 'cert', key)
out_file_dir = os.path.join(dir, 'data', out_file_name)

client = Betfair('OclZSgXWwsQNpQky', '{}'.format(base_dir))
client.login(username='******', password='******')
client.keep_alive()

url = client.api_url
headers = client.headers


def callAping(jsonrpc_req):
    try:
        req = request.Request(url, jsonrpc_req.encode('utf-8'), headers)
        response = urllib.request.urlopen(req)
        jsonResponse = response.read()
        return jsonResponse.decode('utf-8')
    except HTTPError:
        print('Not a valid operation from the service ' + str(url))
        exit()
Пример #2
0
def betfair_get(self, is_ip, counter, sport='Tennis'):
    start = timezone.now()
    ip = 'ip' if is_ip else 'ni'

    client = Betfair('GkhXY3b3KmncnwLe', 'certs/bf.pem')
    # client = Betfair('uv9hV1EjlFimHmgr', 'certs/bf.pem')
    client.login('sherst', 'osT1G11nRe35')
    client.keep_alive()
    tennis_event_type = self.sports[sport]
    markets = client.list_market_catalogue(
        MarketFilter(event_type_ids=[tennis_event_type],
                     market_type_codes=["MATCH_ODDS"],
                     in_play_only=is_ip),
        market_projection=["EVENT", "RUNNER_METADATA", "COMPETITION"],
        max_results=200)
    mids = [m.market_id for m in markets]
    mids_portions = [mids[x:x + 40] for x in xrange(0, len(mids), 40)]
    for mp in mids_portions:
        print(','.join(mp))
        books = client.list_market_book(
            mp,
            price_projection=PriceProjection(
                price_data=betfair.constants.PriceData.EX_BEST_OFFERS))
        for b in books:
            m = next((x for x in markets if x.market_id == b.market_id), None)
            if m.competition == None: continue
            bfcid = m.competition.id
            champname = m.competition.name
            country = m.event.country_code
            event_id = m.event.id
            ds = timezone.make_aware(m.event.open_date)
            p1 = m.runners[0].runner_name
            if (p1 == None or '/' in p1):
                continue
            rid1 = m.runners[0].selection_id
            p2 = m.runners[1].runner_name
            rid2 = m.runners[1].selection_id
            event, created = BFEvent.objects.get_or_create(bfid=event_id)
            if (created):
                champ = self.save_champ(bfcid, champname, tennis_event_type,
                                        country)
                player1 = self.save_player(p1)
                player2 = self.save_player(p2)
                event.cid = champ
                event.rid1 = rid1
                event.rid2 = rid2
                event.pid1 = player1
                event.pid2 = player2
                event.dt = ds
                event.status = 1 if is_ip else 0
                event.save()
            p1b1_odds = b.runners[0].ex.available_to_back[0].price if len(
                b.runners[0].ex.available_to_back) > 0 else 0
            p1b1_size = b.runners[0].ex.available_to_back[0].size if len(
                b.runners[0].ex.available_to_back) > 0 else 0
            p1l1_odds = b.runners[0].ex.available_to_lay[0].price if len(
                b.runners[0].ex.available_to_lay) > 0 else 0
            p1l1_size = b.runners[0].ex.available_to_lay[0].size if len(
                b.runners[0].ex.available_to_lay) > 0 else 0
            p2b1_odds = b.runners[1].ex.available_to_back[0].price if len(
                b.runners[1].ex.available_to_back) > 0 else 0
            p2b1_size = b.runners[1].ex.available_to_back[0].size if len(
                b.runners[1].ex.available_to_back) > 0 else 0
            p2l1_odds = b.runners[1].ex.available_to_lay[0].price if len(
                b.runners[1].ex.available_to_lay) > 0 else 0
            p2l1_size = b.runners[1].ex.available_to_lay[0].size if len(
                b.runners[1].ex.available_to_lay) > 0 else 0
            if (self.is_debug):
                self.stdout.write('*** evid [%s] %s - %s at %s, changed %s\n' %
                                  (event.id, event.pid1.name, event.pid2.name,
                                   event.dt, event.dtc),
                                  ending='')
            try:
                odds = BFOdds.objects.filter(eid=event).latest('dtc')
                if (odds.b1odds != p1b1_odds or odds.b2odds != p2b1_odds
                        or odds.l1odds != p1l1_odds
                        or odds.l2odds != p2l1_odds):
                    self.save_odds(event, p1b1_odds, p2b1_odds, p1l1_odds,
                                   p2l1_odds, p1b1_size, p2b1_size, p1l1_size,
                                   p2l1_size, is_ip)
                    if (self.is_debug):
                        self.stdout.write(
                            'evid[%s], mid[%s] %s %s - %s in %s: %s/%s\n' %
                            (event_id, b.market_id, ds, p1.replace(
                                '\\', ''), p2.replace('\\', ''), country,
                             b.total_matched, b.total_available),
                            ending='')
                        self.stdout.write(
                            '[%s]%s:%s@%s\t|%s@%s\n' %
                            (rid1, p1.replace('\\', ''), p1b1_size, p1b1_odds,
                             p1l1_size, p1l1_odds),
                            ending='')
                        self.stdout.write(
                            '[%s]%s:%s@%s\t|%s@%s\n' %
                            (rid2, p2.replace('\\', ''), p2b1_size, p2b1_odds,
                             p2l1_size, p2l1_odds),
                            ending='')
            except:
                self.save_odds(event, p1b1_odds, p2b1_odds, p1l1_odds,
                               p2l1_odds, p1b1_size, p2b1_size, p1l1_size,
                               p2l1_size, is_ip)
                if (self.is_debug):
                    self.stdout.write(
                        'evid[%s], mid[%s] %s %s - %s in %s: %s/%s\n' %
                        (event_id, b.market_id, ds, p1.replace(
                            '\\', ''), p2.replace('\\', ''), country,
                         b.total_matched, b.total_available),
                        ending='')
                    self.stdout.write('[%s]%s:%s@%s\t|%s@%s\n' %
                                      (rid1, p1.replace('\\', ''), p1b1_size,
                                       p1b1_odds, p1l1_size, p1l1_odds),
                                      ending='')
                    self.stdout.write('[%s]%s:%s@%s\t|%s@%s\n' %
                                      (rid2, p2.replace('\\', ''), p2b1_size,
                                       p2b1_odds, p2l1_size, p2l1_odds),
                                      ending='')
    end = timezone.now()
    log = ALog()
    log.name = 'update_bf_%s_%s' % (sport, ip)
    log.dts = start
    log.counter = counter
    log.duration = (end - start).total_seconds()
    log.save()
    if (self.is_debug):
        self.stdout.write('total execution is %s seconds\n' % (end - start),
                          ending='')
Пример #3
0
import json
import betfair

from betfair import Betfair
client = Betfair('eTnX7n6jsiaoGA9g', ('certs/client-2048.crt', 'certs/client-2048.key'))
print 'Logging in'
client.login('*****@*****.**', 'wyeslsc10')

print 'Keeping alive'
client.keep_alive()

account_details = client.get_account_details()
print account_details
a = account_details.currency_code
print a


from betfair.models import MarketFilter
event_types = client.list_event_types(MarketFilter(text_query='tennis'))
print event_types
print event_types[0]
print event_types[0].event_type

print(len(event_types))                 # 2
print(event_types[0].event_type.name)   # 'Tennis'

tennis_event_type = event_types[0]
markets = client.list_market_catalogue(MarketFilter(event_type_ids=[tennis_event_type.event_type.id]))
print markets[0].market_name                  # 'Djokovic Tournament Wins'

client.logout()