def __init__(self, request):
super(UpdateDBViewer, self).__init__(request)
#self.layout.main_menu = make_main_menu(self.request).render()
#self.layout.ctx_menu = make_ctx_menu(self.request).output()
make_context_menu(self.request)
self.games = NFLGameManager(self.request.db)
self.odds = NFLOddsManager(self.request.db)
self.bets = BetsManager(self.request.db)
settings = self.get_app_settings()
url = settings['vignewton.nfl.odds.url']
self.odds.oddscache.set_url(url)
url = settings['vignewton.nfl.schedule.url']
self.games.schedules.set_url(url)
self.mgr = UpdateDBManager(self.request.db)
self.context = self.request.matchdict['context']
# make dispatch table
self._cntxt_meth = dict(
main=self.main_view,
games=self.update_games,
odds=self.update_odds,
bets=self.determine_bets,
report=self.show_update_report,
)
if self.context in self._cntxt_meth:
self._cntxt_meth[self.context]()
else:
msg = 'Undefined Context: %s' % self.context
self.layout.content = '<b>%s</b>' % msg
def even_more_setup(env):
from vignewton.managers.util import parse_odds_html
games = parse_odds_html(text)
env['games'] = games
#from vignewton.models.main import NFLGame
gm = NFLGameManager(db)
env['gm'] = gm
dbgames = [gm.get_game_from_odds(g) for g in games]
env['dbgames'] = dbgames
from vignewton.managers.odds import NFLOddsManager
om = NFLOddsManager(db)
env['om'] = om
om.oddscache.set_url(odds_url)
def even_more_setup(env):
from vignewton.managers.util import parse_odds_html
games = parse_odds_html(text)
env['games'] = games
#from vignewton.models.main import NFLGame
gm = NFLGameManager(db)
env['gm'] = gm
dbgames = [gm.get_game_from_odds(g) for g in games]
env['dbgames'] = dbgames
from vignewton.managers.odds import NFLOddsManager
om = NFLOddsManager(db)
env['om'] = om
om.oddscache.set_url(odds_url)
def __init__(self, request):
super(UpdateDBViewer, self).__init__(request)
#self.layout.main_menu = make_main_menu(self.request).render()
#self.layout.ctx_menu = make_ctx_menu(self.request).output()
make_context_menu(self.request)
self.games = NFLGameManager(self.request.db)
self.odds = NFLOddsManager(self.request.db)
self.bets = BetsManager(self.request.db)
settings = self.get_app_settings()
url = settings['vignewton.nfl.odds.url']
self.odds.oddscache.set_url(url)
url = settings['vignewton.nfl.schedule.url']
self.games.schedules.set_url(url)
self.mgr = UpdateDBManager(self.request.db)
self.context = self.request.matchdict['context']
# make dispatch table
self._cntxt_meth = dict(
main=self.main_view,
games=self.update_games,
odds=self.update_odds,
bets=self.determine_bets,
report=self.show_update_report,
)
if self.context in self._cntxt_meth:
self._cntxt_meth[self.context]()
else:
msg = 'Undefined Context: %s' % self.context
self.layout.content = '<b>%s</b>' % msg
class GameCalJSONViewer(BaseViewer):
def __init__(self, request):
super(MainCalJSONViewer, self).__init__(request)
self.nfl_games = NFLGameManager(self.request.db)
self.get_everthing()
def _get_start_end_userid(self, user_id=True):
start = self.request.GET['start']
end = self.request.GET['end']
if user_id:
user_id = self.request.session['user'].id
return start, end, user_id
def _get_start_end(self):
start = self.request.GET['start']
end = self.request.GET['end']
return start, end
def serialize_game_for_calendar(self, game):
data = dict(title=game.summary, start=game.start.isoformat(),
end=game.end.isoformat())
return data
def get_everthing(self):
start, end = self._get_start_end()
serialize = self.serialize_game_for_calendar
nfl_games = self.nfl_games.get_games(start, end, timestamps=True)
self.response = [serialize(g) for g in nfl_games]
class TeamCalJSONViewer(BaseViewer):
def __init__(self, request):
super(MainCalJSONViewer, self).__init__(request)
self.nfl_games = NFLGameManager(self.request.db)
self.get_everthing()
def _get_start_end_userid(self, user_id=True):
start = self.request.GET['start']
end = self.request.GET['end']
if user_id:
user_id = self.request.session['user'].id
return start, end, user_id
def _get_start_end(self):
start = self.request.GET['start']
end = self.request.GET['end']
return start, end
def serialize_game_for_calendar(self, game):
data = dict(title=game.summary,
start=game.start.isoformat(),
end=game.end.isoformat())
return data
def get_everthing(self):
start, end = self._get_start_end()
serialize = self.serialize_game_for_calendar
nfl_games = self.nfl_games.get_games(start, end, timestamps=True)
self.response = [serialize(g) for g in nfl_games]
def __init__(self, request):
super(BetsViewer, self).__init__(request)
#self.layout.main_menu = make_main_menu(self.request).render()
#self.layout.ctx_menu = make_ctx_menu(self.request).output()
make_context_menu(self.request)
self.accounts = AccountingManager(self.request.db)
self.teams = NFLTeamManager(self.request.db)
self.games = NFLGameManager(self.request.db)
self.odds = NFLOddsManager(self.request.db)
self.bets = BetsManager(self.request.db)
settings = self.get_app_settings()
url = settings['vignewton.nfl.odds.url']
self.odds.oddscache.set_url(url)
self.context = self.request.matchdict['context']
# make dispatch table
self._cntxt_meth = dict(
main=self.main_view,
allpending=self.view_all_pending_bets,
allclosed=self.view_all_closed_bets,
)
if self.context in self._cntxt_meth:
self._cntxt_meth[self.context]()
else:
msg = 'Undefined Context: %s' % self.context
self.layout.content = '<b>%s</b>' % msg
def setup(env):
request = env['request']
db = request.db
env['db'] = db
settings = env['registry'].settings
url = settings['vignewton.nfl.schedule.url']
env['url'] = url
odds_url = settings['vignewton.nfl.odds.url']
from vignewton.managers.nflgames import NFLTeamManager
tm = NFLTeamManager(db)
env['tm'] = tm
from vignewton.managers.odds import NFLOddsManager
om = NFLOddsManager(db)
env['om'] = om
om.oddscache.set_url(odds_url)
if not om.get_current_odds():
filename = 'testdata/o.pickle'
if not os.path.isfile(filename):
om.update_current_odds()
else:
om.populate_from_pickle(filename)
from vignewton.managers.nflgames import NFLGameManager
gm = NFLGameManager(db)
env['gm'] = gm
gm.set_schedule_url(url)
update_game_schedule = False
if update_game_schedule:
update_games(gm)
env['ug'] = update_games
from vignewton.managers.accounting import AccountingManager
am = AccountingManager(db)
am.initialize_bets_manager()
env['am'] = am
#env['games'] = om.oddscache.get_latest()[0].content
#env['bg'] = env['games'][-3]
from vignewton.managers.util import determine_max_bet
env['dmb'] = determine_max_bet
env['game'] = gm.query().get(125)
backup_cache(gm, om)
from vignewton.managers.bets import BetsManager
bm = BetsManager(db)
env['bm'] = bm
from vignewton.managers.util import chop_ical_nflgame_desc
env['cind'] = chop_ical_nflgame_desc
env['g'] = gm.get(131)
def __init__(self, session):
self.session = session
self.games = NFLGameManager(self.session)
self.teams = NFLTeamManager(self.session)
self.odds = NFLOddsManager(self.session)
self.accounts = AccountingManager(self.session)
# FIXME: put this in config or database
self.max_bet = 500
def __init__(self, request):
super(NFLGameViewer, self).__init__(request)
self.layout.main_menu = make_main_menu(self.request).render()
self.layout.ctx_menu = make_ctx_menu(self.request).output()
self.teams = NFLTeamManager(self.request.db)
self.games = NFLGameManager(self.request.db)
self.context = self.request.matchdict['context']
# make dispatch table
self._cntxt_meth = dict(
main=self.main_view,
viewgame=self.view_game,
)
if self.context in self._cntxt_meth:
self._cntxt_meth[self.context]()
else:
msg = 'Undefined Context: %s' % self.context
self.layout.content = '<b>%s</b>' % msg
def __init__(self, request):
super(MainViewer, self).__init__(request)
prepare_main_data(request)
self.games = NFLGameManager(self.request.db)
self.odds = NFLOddsManager(self.request.db)
self.bets = BetsManager(self.request.db)
template = 'vignewton:templates/admin-main-view.mako'
env = dict(odds=self.odds, games=self.games, bets=self.bets)
content = self.render(template, env)
self.layout.content = content
def __init__(self, request):
super(NFLGameViewer, self).__init__(request)
self.layout.main_menu = make_main_menu(self.request).render()
self.layout.ctx_menu = make_ctx_menu(self.request).output()
self.teams = NFLTeamManager(self.request.db)
self.games = NFLGameManager(self.request.db)
self.context = self.request.matchdict['context']
# make dispatch table
self._cntxt_meth = dict(
main=self.main_view,
viewgame=self.view_game,
)
if self.context in self._cntxt_meth:
self._cntxt_meth[self.context]()
else:
msg = 'Undefined Context: %s' % self.context
self.layout.content = '<b>%s</b>' % msg
class NFLGameViewer(BaseViewer):
def __init__(self, request):
super(NFLGameViewer, self).__init__(request)
self.layout.main_menu = make_main_menu(self.request).render()
self.layout.ctx_menu = make_ctx_menu(self.request).output()
self.teams = NFLTeamManager(self.request.db)
self.games = NFLGameManager(self.request.db)
self.context = self.request.matchdict['context']
# make dispatch table
self._cntxt_meth = dict(
main=self.main_view,
viewgame=self.view_game,
)
if self.context in self._cntxt_meth:
self._cntxt_meth[self.context]()
else:
msg = 'Undefined Context: %s' % self.context
self.layout.content = '<b>%s</b>' % msg
def main_view(self):
self.layout.subheader = 'NFL Teams'
teams = self.teams.all()
template = 'vignewton:templates/main-nfl-teams-view.mako'
env = dict(teams=teams)
content = self.render(template, env)
self.layout.content = content
def view_game(self):
id = self.request.matchdict['id']
game = self.games.get(id)
self.layout.content = '<pre>%s</pre>' % game.description
#now = datetime.now()
#template = 'vignewton:templates/view-nfl-team.mako'
#env = dict(team=team, games=games, now=now)
#content = self.render(template, env)
#self.layout.content = content
x = id
class NFLGameViewer(BaseViewer):
def __init__(self, request):
super(NFLGameViewer, self).__init__(request)
self.layout.main_menu = make_main_menu(self.request).render()
self.layout.ctx_menu = make_ctx_menu(self.request).output()
self.teams = NFLTeamManager(self.request.db)
self.games = NFLGameManager(self.request.db)
self.context = self.request.matchdict['context']
# make dispatch table
self._cntxt_meth = dict(
main=self.main_view,
viewgame=self.view_game,
)
if self.context in self._cntxt_meth:
self._cntxt_meth[self.context]()
else:
msg = 'Undefined Context: %s' % self.context
self.layout.content = '<b>%s</b>' % msg
def main_view(self):
self.layout.subheader = 'NFL Teams'
teams = self.teams.all()
template = 'vignewton:templates/main-nfl-teams-view.mako'
env = dict(teams=teams)
content = self.render(template, env)
self.layout.content = content
def view_game(self):
id = self.request.matchdict['id']
game = self.games.get(id)
self.layout.content = '<pre>%s</pre>' % game.description
#now = datetime.now()
#template = 'vignewton:templates/view-nfl-team.mako'
#env = dict(team=team, games=games, now=now)
#content = self.render(template, env)
#self.layout.content = content
x = id
def setup(env):
request = env['request']
db = request.db
env['db'] = db
settings = env['registry'].settings
url = settings['vignewton.nfl.schedule.url']
env['url'] = url
odds_url = settings['vignewton.nfl.odds.url']
from vignewton.managers.nflgames import NFLTeamManager
tm = NFLTeamManager(db)
env['tm'] = tm
from vignewton.managers.odds import NFLOddsManager
om = NFLOddsManager(db)
env['om'] = om
om.oddscache.set_url(odds_url)
if not om.get_current_odds():
filename = 'testdata/o.pickle'
if not os.path.isfile(filename):
om.update_current_odds()
else:
om.populate_from_pickle(filename)
from vignewton.managers.nflgames import NFLGameManager
gm = NFLGameManager(db)
env['gm'] = gm
gm.set_schedule_url(url)
update_game_schedule = False
if update_game_schedule:
update_games(gm)
env['ug'] = update_games
from vignewton.managers.accounting import AccountingManager
am = AccountingManager(db)
am.initialize_bets_manager()
env['am'] = am
#env['games'] = om.oddscache.get_latest()[0].content
#env['bg'] = env['games'][-3]
from vignewton.managers.util import determine_max_bet
env['dmb'] = determine_max_bet
env['game'] = gm.query().get(125)
backup_cache(gm, om)
from vignewton.managers.bets import BetsManager
bm = BetsManager(db)
env['bm'] = bm
from vignewton.managers.util import chop_ical_nflgame_desc
env['cind'] = chop_ical_nflgame_desc
env['g'] = gm.get(131)
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
# set app name
appname = 'vignewton'
# need to use goout root factory for ACL
root_factory = 'vignewton.resources.RootGroupFactory'
# alchemy request provides .db method
request_factory = 'trumpet.request.AlchemyRequest'
# get admin username
admin_username = settings.get('vignewton.admin.admin_username', 'admin')
# create db engine
engine = engine_from_config(settings, 'sqlalchemy.')
# setup db.sessionmaker
settings['db.sessionmaker'] = DBSession
# bind session to engine
DBSession.configure(bind=engine)
# bind objects to engine
Base.metadata.bind = engine
if settings.get('db.populate', 'False') == 'True':
from sqlalchemy.exc import IntegrityError
from vignewton.models.main import make_test_data
Base.metadata.create_all(engine)
#initialize_sql(engine)
#make_test_data(DBSession)
from vignewton.models.usergroup import populate_groups
populate_groups()
from vignewton.models.usergroup import populate
populate(admin_username)
from vignewton.models.sitecontent import populate_sitetext
populate_sitetext()
import transaction
filename = 'testdata/nfl-teams.csv'
if os.path.isfile(filename):
from sqlalchemy.exc import IntegrityError
from vignewton.managers.nflgames import NFLTeamManager
from vignewton.managers.util import get_nfl_teams
m = NFLTeamManager(DBSession)
teams = get_nfl_teams(filename)
try:
m.populate_teams(teams)
except IntegrityError:
transaction.abort()
filename = 'testdata/nfl.ics'
if os.path.isfile(filename):
from vignewton.managers.nflgames import NFLGameManager
m = NFLGameManager(DBSession)
try:
m.populate_games(file(filename).read())
except IntegrityError:
import transaction
transaction.abort()
from vignewton.models.main import populate_accounting_tables
populate_accounting_tables(DBSession)
# setup authn and authz
secret = settings['%s.authn.secret' % appname]
cookie = settings['%s.authn.cookie' % appname]
timeout = int(settings['%s.authn.timeout' % appname])
authn_policy, authz_policy = make_authn_authz_policies(
secret, cookie, callback=authenticate,
timeout=timeout, tkt=False)
# create config object
config = Configurator(settings=settings,
root_factory=root_factory,
request_factory=request_factory,
authentication_policy=authn_policy,
authorization_policy=authz_policy)
session_factory = session_factory_from_settings(settings)
config.set_session_factory(session_factory)
config.include('pyramid_fanstatic')
configure_base_layout(config)
configure_admin(config)
configure_wiki(config, '/vig_wiki')
config.add_static_view('static',
'vignewton:static', cache_max_age=3600)
##################################
# Main Views
##################################
config.add_route('home', '/')
config.add_view('vignewton.views.main.MainViewer',
layout='base',
renderer=basetemplate,
route_name='home')
config.add_route('main', '/main/{context}/{id}')
config.add_view('vignewton.views.main.MainViewer',
permission='user',
layout='base',
renderer=basetemplate,
route_name='main',)
config.add_route('initdb', '/initdb/{context}/{id}')
config.add_view('vignewton.views.main.MainViewer',
layout='base',
renderer=basetemplate,
route_name='initdb')
route_name = 'maincal_json'
config.add_route(route_name, '/%s/{context}/{id}' % route_name)
config.add_view('vignewton.views.main.MainCalJSONViewer',
permission='user',
route_name=route_name,
renderer='json',
layout='base',)
route_name = 'vig_nflteams'
config.add_route(route_name, '/vignflteams/{context}/{id}')
config.add_view('vignewton.views.teams.NFLTeamViewer',
permission='user',
layout='base',
renderer=basetemplate,
route_name=route_name)
route_name = 'vig_nflgames'
config.add_route(route_name, '/vignflgames/{context}/{id}')
config.add_view('vignewton.views.games.NFLGameViewer',
permission='user',
layout='base',
renderer=basetemplate,
route_name=route_name)
route_name = 'vig_betgames'
config.add_route(route_name, '/vigbetgames/{context}/{id}')
config.add_view('vignewton.views.betgames.NFLGameBetsViewer',
permission='user',
layout='base',
renderer=basetemplate,
route_name=route_name)
route_name = 'vig_betfrag'
config.add_route(route_name, '/vigbetfrag/{context}/{id}')
config.add_view('vignewton.views.betgames.NFLBetFrag',
permission='user',
layout='base',
renderer='string',
route_name=route_name)
route_name = 'vig_really_bet'
match = '/vigmakebet/{game_id}/{bettype}/{amount}/{betval}'
config.add_route(route_name, match)
config.add_view('vignewton.views.betgames.NFLGameBetsViewer',
permission='user',
layout='base',
renderer=basetemplate,
route_name=route_name)
##################################
# Login Views
##################################
login_viewer = 'vignewton.views.login.LoginViewer'
config.add_route('login', '/login')
config.add_view(login_viewer,
renderer=basetemplate,
layout='base',
route_name='login')
config.add_route('logout', '/logout')
config.add_view(login_viewer,
renderer=basetemplate,
layout='base',
route_name='logout')
# Handle HTTPForbidden errors with a
# redirect to a login page.
config.add_view(login_viewer,
context='pyramid.httpexceptions.HTTPForbidden',
renderer=basetemplate,
layout='base')
##################################
config.add_route('blob', '/blob/{filetype}/{id}')
config.add_view('vignewton.views.blob.BlobViewer', route_name='blob',
renderer='string',
layout='base')
##################################
# Views for Users
##################################
config.add_route('user', '/user/{context}')
config.add_view('vignewton.views.userview.MainViewer',
route_name='user',
renderer=basetemplate,
layout='base',
permission='user')
##################################
# wrap app with Fanstatic
app = config.make_wsgi_app()
from fanstatic import Fanstatic
return Fanstatic(app)
def __init__(self, request):
super(MainCalJSONViewer, self).__init__(request)
self.nfl_games = NFLGameManager(self.request.db)
self.get_everthing()
class UpdateDBViewer(AdminViewer):
def __init__(self, request):
super(UpdateDBViewer, self).__init__(request)
#self.layout.main_menu = make_main_menu(self.request).render()
#self.layout.ctx_menu = make_ctx_menu(self.request).output()
make_context_menu(self.request)
self.games = NFLGameManager(self.request.db)
self.odds = NFLOddsManager(self.request.db)
self.bets = BetsManager(self.request.db)
settings = self.get_app_settings()
url = settings['vignewton.nfl.odds.url']
self.odds.oddscache.set_url(url)
url = settings['vignewton.nfl.schedule.url']
self.games.schedules.set_url(url)
self.mgr = UpdateDBManager(self.request.db)
self.context = self.request.matchdict['context']
# make dispatch table
self._cntxt_meth = dict(
main=self.main_view,
games=self.update_games,
odds=self.update_odds,
bets=self.determine_bets,
report=self.show_update_report,
)
if self.context in self._cntxt_meth:
self._cntxt_meth[self.context]()
else:
msg = 'Undefined Context: %s' % self.context
self.layout.content = '<b>%s</b>' % msg
def main_view(self):
self.layout.header = 'Main Update View'
self.layout.content = 'Main Update View'
def update_games(self):
updated = self.games.update_games()
if updated:
self.layout.content = 'Game Schedule updated.'
else:
self.layout.content = 'No need to update yet.'
def update_odds(self):
olist, updated = self.odds.update_current_odds()
if updated:
self.layout.content = 'Game Odds updated.'
else:
self.layout.content = 'No need to update yet.'
def determine_bets(self):
template = 'vignewton:templates/admin-determine-bets.mako'
clist = self.bets.determine_bets()
env = dict(bm=self.bets, clist=clist)
content = self.render(template, env)
self.layout.content = content
def show_update_report(self):
reports = self.mgr.get_all()
template = 'vignewton:templates/admin-full-update-report.mako'
env = dict(reports=reports)
content = self.render(template, env)
self.layout.content = content
class UpdateDBManager(object):
def __init__(self, session):
self.session = session
self.games = NFLGameManager(self.session)
self.odds = NFLOddsManager(self.session)
self.bets = BetsManager(self.session)
def set_schedule_url(self, url):
self.games.schedules.set_url(url)
def set_schedule_ttl(self, **kw):
self.games.schedules.set_ttl(**kw)
def set_odds_url(self, url):
self.odds.oddscache.set_url(url)
def set_odds_ttl(self, **kw):
self.odds.oddscache.set_ttl(**kw)
def query(self):
return self.session.query(UpdateReport)
def get(self, report_id):
return self.query().get(report_id)
def _order_desc_filter(self, query):
return query.order_by(UpdateReport.created.desc())
def get_latest(self):
q = self.query()
q = self._order_desc_filter(q)
return q.first()
def get_all(self):
q = self.query()
q = self._order_desc_filter(q)
return q.all()
def _add_report(self, content):
with transaction.manager:
now = datetime.now()
ur = UpdateReport()
ur.created = now
ur.content = content
self.session.add(ur)
return self.session.merge(ur)
def _update_database(self):
games_updated = self.games.update_games()
#games_updated = False
oddslist, odds_updated = self.odds.update_current_odds()
determined = self.bets.determine_bets()
oddslist = [serialize_odds(o) for o in oddslist]
determined = [serialize_closed_bet(b) for b in determined]
data = dict(games_updated=games_updated,
odds_updated=odds_updated,
oddslist=oddslist, determined=determined)
return data
def update(self):
content = self._update_database()
report = self._add_report(content)
return report
def __init__(self, session):
self.session = session
self.games = NFLGameManager(self.session)
self.odds = NFLOddsManager(self.session)
self.bets = BetsManager(self.session)
def __init__(self, session):
self.session = session
self.games = NFLGameManager(self.session)
self.odds = NFLOddsManager(self.session)
self.bets = BetsManager(self.session)
def __init__(self, session):
self.session = session
self.games = NFLGameManager(self.session)
self.teams = NFLTeamManager(self.session)
self.oddscache = NFLOddsCache(self.session)
class UpdateDBManager(object):
def __init__(self, session):
self.session = session
self.games = NFLGameManager(self.session)
self.odds = NFLOddsManager(self.session)
self.bets = BetsManager(self.session)
def set_schedule_url(self, url):
self.games.schedules.set_url(url)
def set_schedule_ttl(self, **kw):
self.games.schedules.set_ttl(**kw)
def set_odds_url(self, url):
self.odds.oddscache.set_url(url)
def set_odds_ttl(self, **kw):
self.odds.oddscache.set_ttl(**kw)
def query(self):
return self.session.query(UpdateReport)
def get(self, report_id):
return self.query().get(report_id)
def _order_desc_filter(self, query):
return query.order_by(UpdateReport.created.desc())
def get_latest(self):
q = self.query()
q = self._order_desc_filter(q)
return q.first()
def get_all(self):
q = self.query()
q = self._order_desc_filter(q)
return q.all()
def _add_report(self, content):
with transaction.manager:
now = datetime.now()
ur = UpdateReport()
ur.created = now
ur.content = content
self.session.add(ur)
return self.session.merge(ur)
def _update_database(self):
games_updated = self.games.update_games()
#games_updated = False
oddslist, odds_updated = self.odds.update_current_odds()
determined = self.bets.determine_bets()
oddslist = [serialize_odds(o) for o in oddslist]
determined = [serialize_closed_bet(b) for b in determined]
data = dict(games_updated=games_updated,
odds_updated=odds_updated,
oddslist=oddslist,
determined=determined)
return data
def update(self):
content = self._update_database()
report = self._add_report(content)
return report
class NFLOddsManager(object):
def __init__(self, session):
self.session = session
self.games = NFLGameManager(self.session)
self.teams = NFLTeamManager(self.session)
self.oddscache = NFLOddsCache(self.session)
def query(self):
return self.session.query(NFLGameOdds)
def get(self, game_id):
return self.query().get(game_id)
def archive_cache_table(self):
return self.oddscache.archive_table("odds")
def get_odds(self, game_id):
q = self.query()
q = q.filter_by(game_id=game_id)
return q.one()
def get_data(self, odds):
data = dict(favored_id=odds.favored_id, underdog_id=odds.underdog_id, total=odds.total, spread=odds.spread)
return data
def _fix_number(self, numstr):
numstr = numstr.encode("utf-8")
numstr = numstr.strip()
add_one_half = False
if numstr.endswith("\xc2\xbd"):
add_one_half = True
numstr = numstr[:-2]
if not numstr or numstr == "-":
number = 0
else:
number = int(numstr)
if add_one_half:
number = number + 0.5
return number
def _determine_favored(self, game):
away = game["away"]
home = game["home"]
if game["away_line"] == "-":
favored_id = self.games.fnlookup[home]
underdog_id = self.games.fnlookup[home]
spread = "0"
else:
plusminus = game["away_line"][0]
if plusminus == "-":
favored_id = self.games.fnlookup[away]
underdog_id = self.games.fnlookup[home]
if game["home_line"][0] == "-":
raise RuntimeError, "bad values for game %s" % game
else:
favored_id = self.games.fnlookup[home]
underdog_id = self.games.fnlookup[away]
if game["home_line"][0] == "+":
raise RuntimeError, "bad values for game %s" % game
spread = game["away_line"][1:].split("(")[0]
spread = self._fix_number(spread)
return favored_id, underdog_id, spread
def add_game_odds(self, game_id, game):
favored_id, underdog_id, spread = self._determine_favored(game)
total = game["total"]
total = self._fix_number(total)
now = datetime.now()
with transaction.manager:
odds = NFLGameOdds()
odds.game_id = game_id
odds.retrieved = now
odds.favored_id = favored_id
odds.underdog_id = underdog_id
odds.total = total
odds.spread = spread
self.session.add(odds)
return self.session.merge(odds)
def update_game_odds(self, game_id, game, odds):
total = self._fix_number(game["total"])
spread = game["away_line"][1:].split("(")[0]
spread = self._fix_number(spread)
now = datetime.now()
with transaction.manager:
odds.retrieved = now
odds.total = total
odds.spread = spread
odds = self.session.merge(odds)
return odds
def _populate_odds(self, games):
olist = list()
for game in games:
print "GAMEODDS", game
game_id = self.games.get_game_from_odds(game).id
odds = self.get(game_id)
if odds is not None:
raise OddsPresentError, "odds table should be empty"
odds = self.add_game_odds(game_id, game)
olist.append(odds)
olist = [self.session.merge(o) for o in olist]
return olist
# this is for testing and needs
# an html file to parse
def populate_current_odds(self, filename):
oc = self.oddscache
html = file(filename).read()
oc.parser.set_html(html)
oc.parser.parse()
games = oc.parser.games
latest = oc.add(games)
olist = self._populate_odds(latest.content)
return olist
def populate_from_pickle(self, filename):
games = Pickle.load(file(filename))
return self._populate_odds(games)
def update_current_odds(self):
latest, updated = self.oddscache.get_latest()
oddslist = list()
for game in latest.content:
game_id = self.games.get_game_from_odds(game).id
odds = self.get(game_id)
if odds is None:
odds = self.add_game_odds(game_id, game)
else:
odds = self.update_game_odds(game_id, game, odds)
oddslist.append(odds)
oddslist = [self.session.merge(o) for o in oddslist]
return oddslist, updated
def _filter_zero_odds(self, query):
query = query.filter(NFLGameOdds.total > 0)
query = query.filter(NFLGameOdds.spread > 0)
return query
def get_current_odds(self):
now = datetime.now()
q = self.query()
q = q.filter(NFLGame.start >= now)
q = q.order_by(NFLGame.start)
# q = self._filter_zero_odds(q)
return q.all()
class NFLOddsManager(object):
def __init__(self, session):
self.session = session
self.games = NFLGameManager(self.session)
self.teams = NFLTeamManager(self.session)
self.oddscache = NFLOddsCache(self.session)
def query(self):
return self.session.query(NFLGameOdds)
def get(self, game_id):
return self.query().get(game_id)
def archive_cache_table(self):
return self.oddscache.archive_table('odds')
def get_odds(self, game_id):
q = self.query()
q = q.filter_by(game_id=game_id)
return q.one()
def get_data(self, odds):
data = dict(favored_id=odds.favored_id,
underdog_id=odds.underdog_id,
total=odds.total,
spread=odds.spread)
return data
def _fix_number(self, numstr):
numstr = numstr.encode('utf-8')
numstr = numstr.strip()
add_one_half = False
if numstr.endswith('\xc2\xbd'):
add_one_half = True
numstr = numstr[:-2]
if not numstr or numstr == '-':
number = 0
else:
number = int(numstr)
if add_one_half:
number = number + 0.5
return number
def _determine_favored(self, game):
away = game['away']
home = game['home']
if game['away_line'] == '-':
favored_id = self.games.fnlookup[home]
underdog_id = self.games.fnlookup[home]
spread = '0'
else:
plusminus = game['away_line'][0]
if plusminus == '-':
favored_id = self.games.fnlookup[away]
underdog_id = self.games.fnlookup[home]
if game['home_line'][0] == '-':
raise RuntimeError, "bad values for game %s" % game
else:
favored_id = self.games.fnlookup[home]
underdog_id = self.games.fnlookup[away]
if game['home_line'][0] == '+':
raise RuntimeError, "bad values for game %s" % game
spread = game['away_line'][1:].split('(')[0]
spread = self._fix_number(spread)
return favored_id, underdog_id, spread
def add_game_odds(self, game_id, game):
favored_id, underdog_id, spread = self._determine_favored(game)
total = game['total']
total = self._fix_number(total)
now = datetime.now()
with transaction.manager:
odds = NFLGameOdds()
odds.game_id = game_id
odds.retrieved = now
odds.favored_id = favored_id
odds.underdog_id = underdog_id
odds.total = total
odds.spread = spread
self.session.add(odds)
return self.session.merge(odds)
def update_game_odds(self, game_id, game, odds):
total = self._fix_number(game['total'])
spread = game['away_line'][1:].split('(')[0]
spread = self._fix_number(spread)
now = datetime.now()
with transaction.manager:
odds.retrieved = now
odds.total = total
odds.spread = spread
odds = self.session.merge(odds)
return odds
def _populate_odds(self, games):
olist = list()
for game in games:
print "GAMEODDS", game
game_id = self.games.get_game_from_odds(game).id
odds = self.get(game_id)
if odds is not None:
raise OddsPresentError, "odds table should be empty"
odds = self.add_game_odds(game_id, game)
olist.append(odds)
olist = [self.session.merge(o) for o in olist]
return olist
# this is for testing and needs
# an html file to parse
def populate_current_odds(self, filename):
oc = self.oddscache
html = file(filename).read()
oc.parser.set_html(html)
oc.parser.parse()
games = oc.parser.games
latest = oc.add(games)
olist = self._populate_odds(latest.content)
return olist
def populate_from_pickle(self, filename):
games = Pickle.load(file(filename))
return self._populate_odds(games)
def update_current_odds(self):
latest, updated = self.oddscache.get_latest()
oddslist = list()
for game in latest.content:
game_id = self.games.get_game_from_odds(game).id
odds = self.get(game_id)
if odds is None:
odds = self.add_game_odds(game_id, game)
else:
odds = self.update_game_odds(game_id, game, odds)
oddslist.append(odds)
oddslist = [self.session.merge(o) for o in oddslist]
return oddslist, updated
def _filter_zero_odds(self, query):
query = query.filter(NFLGameOdds.total > 0)
query = query.filter(NFLGameOdds.spread > 0)
return query
def get_current_odds(self):
now = datetime.now()
q = self.query()
q = q.filter(NFLGame.start >= now)
q = q.order_by(NFLGame.start)
#q = self._filter_zero_odds(q)
return q.all()
def __init__(self, session):
self.session = session
self.games = NFLGameManager(self.session)
self.teams = NFLTeamManager(self.session)
self.oddscache = NFLOddsCache(self.session)
def __init__(self, request):
super(MainCalJSONViewer, self).__init__(request)
self.nfl_games = NFLGameManager(self.request.db)
self.get_everthing()
class UpdateDBViewer(AdminViewer):
def __init__(self, request):
super(UpdateDBViewer, self).__init__(request)
#self.layout.main_menu = make_main_menu(self.request).render()
#self.layout.ctx_menu = make_ctx_menu(self.request).output()
make_context_menu(self.request)
self.games = NFLGameManager(self.request.db)
self.odds = NFLOddsManager(self.request.db)
self.bets = BetsManager(self.request.db)
settings = self.get_app_settings()
url = settings['vignewton.nfl.odds.url']
self.odds.oddscache.set_url(url)
url = settings['vignewton.nfl.schedule.url']
self.games.schedules.set_url(url)
self.mgr = UpdateDBManager(self.request.db)
self.context = self.request.matchdict['context']
# make dispatch table
self._cntxt_meth = dict(
main=self.main_view,
games=self.update_games,
odds=self.update_odds,
bets=self.determine_bets,
report=self.show_update_report,
)
if self.context in self._cntxt_meth:
self._cntxt_meth[self.context]()
else:
msg = 'Undefined Context: %s' % self.context
self.layout.content = '<b>%s</b>' % msg
def main_view(self):
self.layout.header = 'Main Update View'
self.layout.content = 'Main Update View'
def update_games(self):
updated = self.games.update_games()
if updated:
self.layout.content = 'Game Schedule updated.'
else:
self.layout.content = 'No need to update yet.'
def update_odds(self):
olist, updated = self.odds.update_current_odds()
if updated:
self.layout.content = 'Game Odds updated.'
else:
self.layout.content = 'No need to update yet.'
def determine_bets(self):
template = 'vignewton:templates/admin-determine-bets.mako'
clist = self.bets.determine_bets()
env = dict(bm=self.bets, clist=clist)
content = self.render(template, env)
self.layout.content = content
def show_update_report(self):
reports = self.mgr.get_all()
template = 'vignewton:templates/admin-full-update-report.mako'
env = dict(reports=reports)
content = self.render(template, env)
self.layout.content = content
