def test_insert(self):
# Disable Foreign Keys checks for this test
TestTeam.db.disableForeignKeys()
with TestTeam.db.transaction() as t:
TestTeam.db.upsert(
Team('team name TD INS', 'league mnemonic TD UPD',
'team season TD UPD'))
objs = TestTeam.db.select(Team())
self.assertEqual(len(objs), 3)
d = eval("{'name': 'team name TD INS'}")
for k, v in d.items():
self.assertEqual(objs[2].__getattribute__('get' + k.title())(),
v)
d = eval(
"{'league': 'league mnemonic TD UPD', 'season': 'team season TD UPD'}"
)
for k, v in d.items():
self.assertEqual(objs[2].__getattribute__('get' + k.title())(),
v)
# force a rollback
t.fail()
def test_select(self):
objs = TestTeam.db.select(Team())
self.assertEqual(len(objs), 2)
self.assertEqual(objs[0].getName(), 'team name TD')
self.assertEqual(objs[0].getLeague(), 'league mnemonic TD')
self.assertEqual(objs[0].getSeason(), 'team season TD')
self.assertEqual(objs[1].getName(), 'team name TD2')
self.assertEqual(objs[1].getLeague(), 'league mnemonic TD2')
self.assertEqual(objs[1].getSeason(), 'team season TD2')
objs = TestTeam.db.select(Team('team name TD'))
self.assertEqual(len(objs), 1)
self.assertEqual(objs[0].getName(), 'team name TD')
self.assertEqual(objs[0].getLeague(), 'league mnemonic TD')
self.assertEqual(objs[0].getSeason(), 'team season TD')
objs = TestTeam.db.select(
Team.createAdhoc({
'league': 'league mnemonic TD',
'season': 'team season TD'
}))
self.assertEqual(len(objs), 1)
self.assertEqual(objs[0].getName(), 'team name TD')
self.assertEqual(objs[0].getLeague(), 'league mnemonic TD')
self.assertEqual(objs[0].getSeason(), 'team season TD')
def test_sourceData_CurrentSeason(self):
with Database(self.dbName, SQLite3Impl()) as db, \
db.transaction() as t:
seasonMap = db.select(Source_Season_Map(98))[0]
seasonMap.setActive(1)
db.upsert(seasonMap)
seasonMap = Source_Season_Map(98, 'season name TD2', \
'source_season_map moniker TD2', \
'source_season_map data_url TD2', 1)
db.upsert(seasonMap)
sourceData(self.mock_Logger, 'source name TD', True)
self.mock_readCSVFileAsDict.assert_any_call( \
'source_season_map data_url TD2')
calls = (
call.info(
'Downloading data from source: source name TD'),
call.debug('Opening database: ./db/test.db'),
call.debug(
"source : Keys {'id': 98} : Values {'name': " \
"'source name TD', 'fixtures_url': 'source " \
"fixtures_url TD', 'url': 'source url TD'}"),
call.debug(
"[source_season_map : Keys {'source_id': 98, "\
"'season': 'season name TD2'} : Values {'moniker'" \
": 'source_season_map moniker TD2', 'data_url': " \
"'source_season_map data_url TD2', 'active': 1}]"),
call.debug(
"[source_league_map : Keys {'source_id': 98, " \
"'league': 'league mnemonic TD'} : Values " \
"{'moniker': 'source_league_map moniker TD'}]"),
call.debug(
"[team : Keys {'name': 'team name TD'} : Values " \
"{'league': 'league mnemonic TD'}, " \
"team : Keys {'name': 'team name TD2'} : Values " \
"{'league': 'league mnemonic TD2'}]"),
call.info('Downloading...source_season_map data_url TD2'),
)
self.mock_Logger.assert_has_calls(calls)
with Database(self.dbName, SQLite3Impl()) as db:
ht = db.select(Team('Coventry', 'league mnemonic TD'))[0]
at = db.select(Team('Cardiff', 'league mnemonic TD'))[0]
match = db.select(Match(201010191))[0]
self.assertTrue(ht and at and match)
self.assertEquals(match.getDate(), '2010-10-19')
self.assertEquals(match.getLeague(), 'league mnemonic TD')
self.assertEquals(match.getHome_Team(), 'Coventry')
self.assertEquals(match.getAway_Team(), 'Cardiff')
self.assertEquals(match.getResult(), 'A')
self.assertEquals(match.getBest_Odds_H(), 3.12)
self.assertEquals(match.getBest_Odds_D(), 3.4)
self.assertEquals(match.getBest_Odds_A(), 2.4)
self.assertEquals(match.getHome_Goals(), 1)
self.assertEquals(match.getAway_Goals(), 2)
self.assertEquals(match.getHome_Lp(), None)
self.assertEquals(match.getAway_Lp(), None)
def test_delete(self):
# Disable Foreign Keys checks for this test
TestTeam.db.disableForeignKeys()
with TestTeam.db.transaction() as t:
TestTeam.db.delete(Team('team name TD'))
objs = TestTeam.db.select(Team())
self.assertEqual(len(objs), 1)
# force a rollback
t.fail()
def test_create(self):
obj = Team.create(
('team name TD', 'league mnemonic TD', 'team season TD'))
self.assertEqual(obj.getName(), 'team name TD')
self.assertEqual(obj.getLeague(), 'league mnemonic TD')
self.assertEqual(obj.getSeason(), 'team season TD')
def sourceData(log: Logger, target: str, currentSeason: bool):
'''
Obtain historical match data
:param log: a logging object
:param target: the name of match data source
:param currentSeason: True if only interested in the current season's data
'''
log.info('Downloading data from source: {}'.format(target))
config = getSweeperConfig()
dbName = config['dbName']
log.debug('Opening database: {}'.format(dbName))
with Database(dbName, SQLite3Impl()) as db, db.transaction() as t:
keys = {'name': target}
source = db.select(Source.createAdhoc(keys))
if source:
source = source[0]
else:
sys.exit('{} source not in database'.format(target))
log.debug('{}'.format(source))
sourceId = source.getId()
keys = {'source_id': sourceId, 'active': 1}
if currentSeason:
seasonMap = db.select(
Source_Season_Map.createAdhoc(keys, ('>season', )))[0:1]
else:
seasonMap = db.select(
Source_Season_Map.createAdhoc(keys, ('>season', )))
log.debug('{}'.format(seasonMap))
keys = {'source_id': sourceId}
leagueMap = db.select(Source_League_Map.createAdhoc(keys))
log.debug('{}'.format(leagueMap))
teams = db.select(Team())
log.debug('{}'.format(teams))
# Process the historical data...
for l in leagueMap:
for s in seasonMap:
url = s.getData_Url().format(l.getLeague())
try:
processMatchData(log, db, url, sourceId, s.getSeason())
except Exception as e:
log.info('Cannot process %s' % url)
# Get the upcoming fixtures too...
processMatchData(log, db, source.getUrl(), sourceId,
seasonMap[0].getSeason(), leagueMap)
def processMatchData(log, db, url, sourceId, season, leagueMap=None):
log.info('Downloading...' + url)
with readCSVFileAsDict(url) as resultsReader:
for row in resultsReader:
try:
dt = datetime.strptime(row['Date'], '%d/%m/%y')
except Exception as e:
try:
dt = datetime.strptime(row['Date'], '%d/%m/%Y')
except:
log.debug('Date conversion failed: {}'.format(e))
continue
try:
lge = row["b'Div"]
except:
lge = row['b"Div']
if leagueMap and lge not in [l.getLeague() for l in leagueMap]:
continue
ht = row['HomeTeam']
keys = {'source_id': sourceId, 'moniker': ht}
teamMap = db.select(Source_Team_Map.createAdhoc(keys))
if teamMap: ht = teamMap[0].getTeam()
db.upsert(Team(ht, lge, season))
at = row['AwayTeam']
keys = {'source_id': sourceId, 'moniker': at}
teamMap = db.select(Source_Team_Map.createAdhoc(keys))
if teamMap: at = teamMap[0].getTeam()
db.upsert(Team(at, lge, season))
bestH, bestD, bestA = getBestOdds(log, row)
match = Match(str(dt.date()), lge, ht, at, \
row['FTR'], bestH, bestD, bestA, \
row['FTHG'], row['FTAG'])
log.debug(match)
db.upsert(match)
def test_repr(self):
obj = Team('team name TD', 'league mnemonic TD', 'team season TD')
self.assertEqual(
str(obj),
"team : Keys {'name': 'team name TD'} : Values {'league': 'league mnemonic TD', 'season': 'team season TD'}"
)
def test_keys_adhoc(self):
l = Team.createAdhoc(None)
self.assertEqual(l.getTable(), 'team')
self.assertTrue(l._keys.getFields() is None)
def test_isNullable(self):
obj = Team()
self.assertTrue(True)
def genLeagueTable(log:Logger, league:str, season:str, date:str=None, \
show:bool=False):
'''
Generate a league table for the subject league and season
:param log: a logging object
:param league: the subject league
:param season: the subject season
:param date: the date string up to which to generate the league YYYY-MM-DD
:param show: displays any tables as HTML when True
'''
log.info('Generating league table for ' \
'league <{}> and season <{}>'.format(league, season))
config = getSweeperConfig()
dbName = config['dbName']
log.debug('Opening database: {}'.format(dbName))
with Database(dbName, SQLite3Impl()) as db, db.transaction() as t:
try:
league = db.select(League(league))[0]
except:
log.critical('No league matching the provided mnemonic exists')
sys.exit(3)
try:
season = db.select(Season(season))[0]
except:
log.critical('No season matching the provided string exists')
sys.exit(4)
ubnd = date if date is not None else season.getU_Bnd_Date()
keys = {'league' : league.getMnemonic(), '!result' : '', '>date' : \
season.getL_Bnd_Date(), '<date' : ubnd}
matches = [m for m in db.select(Match.createAdhoc(keys))]
log.info('{} {} matches found'.format(len(matches), \
league.getMnemonic()))
keys = {'league' : league.getMnemonic(), 'season' : season.getName()}
teams = db.select(Team.createAdhoc(keys))
table = dict([(t.getName(), Form()) for t in teams])
for m in matches:
table[m.getHome_Team()] = h = table.get(m.getHome_Team(), Form())
table[m.getAway_Team()] = a = table.get(m.getAway_Team(), Form())
h.played += 1
a.played += 1
h.glfor += m.getHome_Goals()
h.glagn += m.getAway_Goals()
h.gldif = h.glfor - h.glagn
a.glfor += m.getAway_Goals()
a.glagn += m.getHome_Goals()
a.gldif = a.glfor - a.glagn
if m.getResult() == 'H':
h.won += 1
h.points += 3
a.lost += 1
elif m.getResult() == 'D':
h.drawn += 1
h.points += 1
a.drawn += 1
a.points += 1
elif m.getResult() == 'A':
a.won += 1
a.points += 3
h.lost += 1
else:
raise Exception("Empty result, wasn't expecting that")
headers = ['Team', 'P', 'W', 'D', 'L', 'F', 'A', 'GD', 'PTS']
schema = ['{:<20}', '{:>3}', '{:>3}', '{:>3}', '{:>3}', '{:>3}', \
'{:>3}', '{:>4}', '{:>4}']
t = Table(headers=headers, schema=schema, title='{} Table'.format(\
league.getDesc()))
t.append([[row[0], *row[1].asList()] for row in \
sorted(sorted(table.items(), key=itemgetter(0)), \
key=lambda x : (x[1].points, x[1].gldif, x[1].glfor), \
reverse=True)])
log.info(t)
if show: t.asHTML(show)
return t