/usr/local/lib/python2.4/site-packages/dataplot/soccer/models.py

Go to the documentation of this file.

from django.template.loader import render_to_string
from dataplot import R,GenericPlot
from dataplot import plotmodels as models
#from django.db import models
import pdb,os
#GenericPlot.enable_caching=True

R.SquareScatter.default_kwargs={'marginal':False}

PLAYER_STATS=(
    'games',
    'wins',
    'win_percent',
    'goals_per_game',
    'team_goals_per_game',
    'goals_allowed_per_game',
    'differential',
    )

class PlayerManager(models.Manager):
    """Adds plotting methods.

    """

    def get_ts_data(self):
        """Plot args for making multiple time series of win%

        We should replace this data filtering method with some
        database-backed method, so statistics can be looked up and
        plotted faster/easier.

        """
        data=[
            dict(P.win_percent_plot_args(),name=P.name)
            for P in self.plotable()]
        for D in data:
            v=D['y'][0]
            while v==0 or v==1:
                D['y'].pop(0)
                D['d'].pop(0)
                v=D['y'][0]
        return data

    def plotable(self):
        return self.frequent_players()

    def frequent_players(self):
        return self.filter(games__gte=5)

    def get_goals_and_victories_args(self):
        qs=self.plotable()
        return {
            'x':[x.goals_per_game for x in qs],
            'xlab':"Goals per game",
            'y':[x.win_percent for x in qs],
            'ylab':"Win percent",
            'main':"Goals = victories?",
            'ann':['%s\n%s'%(x.name,x.games) for x in qs],
            }
    
    def wins_diff_args(self):
        qs=self.plotable()
        return {
            'y':[x.win_percent for x in qs],
            'ylab':"Win percent",
            'x':[x.differential for x in qs],
            'xlab':"Differential (average number of points your team wins/loses by)",
            'main':"Win percent versus differential",
            'ann':[x.name for x in qs],
            }

    def SquareScatter_args(self):
        qs=self.plotable()
        return {
            'y':[x.team_goals_per_game for x in qs],
            'ylab':"Team goals per game",
            'x':[x.goals_per_game for x in qs],
            'xlab':"Goals per game",
            'main':"Your contribution to your team's goals",
            'ann':[x.name for x in qs],
            }
    
class Player(models.Model):
    name=models.CharField(
        max_length=100,null=False,blank=True,default='',unique=True)
    goals_per_game=models.FloatField(blank=True,null=True)
    team_goals_per_game=models.FloatField(blank=True,null=True)
    goals_allowed_per_game=models.FloatField(blank=True,null=True)
    differential=models.FloatField(blank=True,null=True)
    games=models.IntegerField(blank=True,null=True)
    wins=models.IntegerField(blank=True,null=True)
    win_percent=models.FloatField(blank=True,null=True)

    objects=PlayerManager()

    URLID='name'

    class Admin:
        fields=(
            (None,{'fields':['name']}),
            )
        list_display=tuple(['name']+list(PLAYER_STATS))

    class Meta:
        ordering=[('name')]

    MANAGER_DATAPLOTS=[
        (R.SquareScatter,{'attribute':'offense_defense','get_plot_args':{
        'x':'team_goals_per_game',
        'y':'inverse_goals_allowed',
        'ann':'name',
        'main':"Defense v. offense"
        }}),
        R.SquareScatter,
        (R.SquareScatter,{'attribute':'wins_diff'}),
        (R.multi_time_series,{'get_plot_args':{
        'x':'get_ts_data',
        'main':"Win percent over time",
        'ylab':"Win percent",
        'xlab':"Game date",
        },'init_args':{'h':9,'w':6.5}}),
        ]

    DATAPLOTS=[
        (R.TimeSeries,{'qs':'scores_ordered','get_plot_args':{
        'd':'game_seconds',
        'y':'goals',
        }}),
        (R.TimeSeries,{'qs':'scores_by_date','attribute':'win_percent_plot',
                       'get_plot_args':{
        'd':'game_seconds',
        'y':'win_percent_until_now',
        'ylab':'Win percent',
        'xlab':'Game date',
        'main':'Win percent change over time'
        }}),
        ]

    def get_absolute_url(self):
        return '/soccer/player/%s/'%self.id

    def inverse_goals_allowed(self):
        return 1/(self.goals_allowed_per_game+1)

    def get_stats(self):
        return [self.get_stat(at) for at in PLAYER_STATS]

    def get_stat(self,at):
        v=getattr(self,at)
        if v==None:
            return
        stat={
            'name':at.replace("_"," ").capitalize(),
            'value':v,
            }
        for side in 'gt','lt','exact':
            di={'%s__%s'%(at,side):v}
            stat[side]=qs=Player.objects.filter(**di)
        return stat

    def scores_ordered(self):
        return order_scores(self.score_set.all())

    def scores_by_date(self):
        return self.score_set.select_related().order_by('soccer_game.date')

    def __str__(self):
        return self.name

    def save(self):
        self.cache()
        super(Player,self).save()

    def save_plots(self): # forces remake of this players plots every save
        self.make_model_plots()

    def cache(self):
        scores=self.score_set.all()
        N=self.games=scores.count()
        if not N:
            return
        self.goals_per_game=float(sum([
            sc.goals for sc in scores]))/N
        # need to make sure cached values are updated first!
        self.goals_allowed_per_game=float(sum([
            sc.points_allowed() for sc in scores]))/N
        self.team_goals_per_game=float(sum([
            sc.team.points for sc in scores]))/N
        diffs=[sc.differential() for sc in scores]
        self.differential=float(sum(diffs))/N
        # maybe use team.won to calc instead?
        self.wins=sum([1 for d in diffs if d > 0])
        self.win_percent=float(self.wins)/N

    def get_absolute_url(self):
        return '/soccer/player/%s/'%self.name

GAME_STATS=(
    'hi_score',
    'lo_score',
    'differential',
    )

class GameManager(models.Manager):
    
    DEFAULT_DATAFILE=os.path.join(os.path.dirname(__file__),'games.txt')
    TUPKEYS=('name','goals','own_goals')
    
    def get_latest(self):
        try:
            return self.order_by('-date')[0]
        except IndexError: # no data yet
            self.create_from_file()
            return self.order_by('-date')[0]

    def create_from_file(self,filename=None):
        """Create new bike rides based on records in a text file.

        """
        filename=filename or self.DEFAULT_DATAFILE
        print "Loading data from %s"%filename
        lines=open(filename).readlines()
        for line in lines: # assume no header line
            print line
            self.create_from_line(line)

    def create_from_line(self,line):
        """Create one game based on line of text datafile.

        """
        from dataplot import GenericPlot
        oldcache=GenericPlot.enable_caching
        GenericPlot.enable_caching=False #
        teamlists=[i.split() for i in line.split(',')]
        G=Game.objects.create(date=teamlists[0].pop(0))
        for L in teamlists:
            T=G.team_set.create(name=L.pop(0))
            like=[L[i::len(self.TUPKEYS)] for i in range(len(self.TUPKEYS))]
            dictlist=[dict(zip(self.TUPKEYS,tup)) for tup in zip(*like)]
            for D in dictlist:
                D['player'],cr=Player.objects.get_or_create(name=D.pop('name'))
                sc=T.score_set.create(**D)
            T.save()
        GenericPlot.enable_caching=oldcache
        return G

    def get_export_text(self):
        """Text for exported data file.

        """
        return '\n'.join([g.export() for g in self.all()])

    def export_games_to_file(self,filename=None):
        """Export data to a text file.

        """
        filename=filename or self.DEFAULT_DATAFILE
        text=self.get_export_text()
        f=open(filename,'w')
        f.write(text)
        f.close()

class Game(models.Model):
    date=models.DateField(blank=False,null=False)
    hi_score=models.IntegerField(blank=True,null=True)
    lo_score=models.IntegerField(blank=True,null=True)
    differential=models.IntegerField(blank=True,null=True)

    objects=GameManager()

    URLID='date'

    class Admin:
        list_display=[
            'date',
            'hi_score',
            'lo_score',
            'differential',
            ]
        fields=(
            (None,{
            'fields':['date']}),
            )

    class Meta:
        ordering=[('date')]

    def export(self):
        teams=self.teams_ordered()
        teamtext=','.join([T.export() for T in teams])
        return '%s %s'%(self.date,teamtext)

    def teams_ordered(self):
        return self.team_set.order_by('-points')

    def cache(self):
        try:
            teams=self.teams_ordered()
            self.hi_score,self.lo_score=[getattr(t,'points') for t in teams]
        except:
            pass
        try:
            self.differential=self.hi_score-self.lo_score
        except:
            pass
    
    def __str__(self):
        return '%s'%self.date

    def get_absolute_url(self):
        return '/soccer/game/%s/'%self.date

    def save(self):
        self.cache()
        super(Game,self).save()
        
def order_scores(qs):
    return qs.select_related().order_by(
        '-goals','own_goals','soccer_player.name')

class Team(models.Model):
    name=models.CharField(max_length=100)
    game=models.ForeignKey(Game)
    goals=models.IntegerField(blank=True,null=True)
    own_goals=models.IntegerField(blank=True,null=True)
    points=models.IntegerField(blank=True,null=True)
    won=models.BooleanField(blank=True,null=False,default=False)
    tied=models.BooleanField(blank=True,null=False,default=False)
    players=models.IntegerField(blank=True,null=True)

    def export(self):
        scores=self.scores_ordered()
        sctext=' '.join([
            '%s %s %s'%(sc.player.name,sc.goals,sc.own_goals)
            for sc in scores])
        return '%s %s'%(self.name,sctext)
        
    def summary(self):
        return render_to_string(
            'soccer/team_summary.html',{'t':self})

    def scores_ordered(self):
        p=getattr(self,'HILITE',None)
        qs=order_scores(self.score_set.all())
        if p:
            for sc in qs:
                sc.is_player=sc.player==self.HILITE
        return qs
            
    def cache(self):
        """Save both teams relevant to this game.

        """
        self.other=self.other_team()
        self.other.other=self
        teams=(self,self.other)
        for t in teams: # totals for each team
            qs=t.score_set.all()
            t.goals=sum([sc.goals for sc in qs])
            t.own_goals=sum([sc.own_goals for sc in qs])
            t.players=qs.count()
        for t in teams: # points based on other teams totals
            t.points=t.goals+sum([
                sc.own_goals for sc in t.other.score_set.all()])
        for t in teams:
            t.won=t.points>t.other.points
            t.tied=t.points==t.other.points
            super(Team,t).save()
        for p in Player.objects.filter(
            score__team__game__id__exact=self.game.id).distinct():
            p.save() # will remake player plots
        Player.make_manager_plots()
        self.game.save()

    def other_team(self):
        try:
            return self.game.team_set.exclude(id=self.id)[0]
        except:
            pass

    def save(self):
        if self.game.team_set.count()==2:
            self.cache()
        else:
            super(Team,self).save()

    def __str__(self):
        return '%s'%self.name

    class Admin:
        list_display=[
            'name',
            'game',
            'players',
            'points',
            'goals',
            'own_goals',
            ]
        fields=[
            (None,{
            'fields':['name','game']}),
            ]
             

class Score(models.Model):
    player=models.ForeignKey(Player,blank=True,null=False,core=True)
    team=models.ForeignKey(Team,edit_inline=True,num_in_admin=10)
    goals=models.IntegerField(null=False,blank=False,default=0,core=True)
    own_goals=models.IntegerField(null=False,blank=False,default=0,core=True)

    def __str__(self):
        return '%s: %s'%(self.player,self.goals)

    def game_seconds(self):
        return self.team.game.date.strftime("%s")

    def win_percent_until_now(self):
        qs=self.player.score_set.filter(
            team__game__date__lte=self.team.game.date)
        wins=qs.filter(team__won__exact=True).count()
        ties=qs.filter(team__tied__exact=True).count()
        games=qs.count()
        pct=(wins*1.0+ties*0.5)/games
        return pct
    
    def points_allowed(self):
        return self.team.other_team().points

    def differential(self):
        return self.team.points-self.team.other_team().points

    def player_summary(self):
        self.team.HILITE=self.player
        return self.team.summary()
    

---