def scrape_league_history(country):
    league_name = countries_leagues[country]
    db.delete_league_by_name(league_name)

    browser.get(main_url)
    more_countries_element = browser.find_element_by_class_name('show-more')
    more_countries_button = more_countries_element.find_element_by_link_text('More')
    execute_script_click(more_countries_button)

    click_league(country, league_name)

    archive_button = browser.find_element_by_link_text('Archive')
    archive_button.click()

    season_names = browser.find_elements_by_class_name('leagueTable__season')[2:]
    season_names = [season.find_element_by_tag_name('a') for season in season_names][::-1]

    league = League(name=league_name, country=country)
    db.save_league(league)

    seasons = [Season(name=get_years_from_season_name(season_name.text), league=league) for season_name in season_names]
    links = [season.get_attribute('href') for season in season_names]

    for season, link in zip(seasons, links):
        scrape_table(link, league, season)
        scrape_results(link, league, season)
    def parseLeague(self):
        sh = self.wb.sheet_by_name(LEAGUE)
        self.teamSrv = ObjSrv()
        header = self.getRow(sh, 0, True)
        unifGrpIdL = header[3:]
        print(unifGrpIdL)
        divD = {}
        for i in range(1, sh.nrows):
            valL = self.getRow(sh, i, True)
            try:
                div = int(valL[0])
            except ValueError:
                div = str(valL[0])

            pool = valL[1]
            team = self.parseTeam(valL[2])
            team.rank = i
            countL = [int(e) for e in valL[3:]]
            team.unifCountD = dict(zip(unifGrpIdL, countL))
            if div not in divD:
                divD[div] = []
            divD[div].append((pool, team))

        divL = []
        for divId, valL in iteritems(divD):
            poolL, teamL = zip(*valL)
            poolS = set(poolL)
            if len(poolS) == 1:
                division = Division('division-%s' % str(divId), teamL)
            elif len(poolS) == 2:
                pool1, pool2 = list(poolS)
                teamL1 = [team for pool, team in valL if pool == pool1]
                teamL2 = [team for pool, team in valL if pool == pool2]
                division = DivisionHalf('division-%s' % str(divId), teamL1,
                                        teamL2)
            else:
                raise Exception(
                    "Can't have more than two pools in the same division (%s)."
                    % (', '.join(map(str, poolS))))

            for team in teamL:
                team.division = division
            divL.append(division)

        self.league = League(divL)
        self.loadLeague(self.league)
    def parseLeague(self):
        sh = self.wb.sheet_by_name(LEAGUE)
        self.teamSrv = ObjSrv()
        header = self.getRow( sh, 0, True )
        unifGrpIdL = header[3:]
        print(unifGrpIdL)
        divD = {}
        for i in range(1,sh.nrows):
            valL = self.getRow( sh, i, True )
            try:
                div = int(valL[0])
            except ValueError:
                div = str(valL[0])

            pool = valL[1]
            team = self.parseTeam(valL[2])
            team.rank = i
            countL = [ int(e) for e in valL[3:] ]
            team.unifCountD = dict( zip(unifGrpIdL, countL ))
            if div not in divD:
                divD[ div ] = []
            divD[div].append( (pool, team ) )


        divL = []
        for divId, valL in iteritems(divD):
            poolL, teamL = zip( *valL )
            poolS = set(poolL)
            if len(poolS) == 1:
                division = Division('division-%s'%str(divId), teamL)
            elif len(poolS) == 2:
                pool1, pool2 = list(poolS)
                teamL1 = [ team for pool, team in valL if pool == pool1 ]
                teamL2 = [ team for pool, team in valL if pool == pool2 ]
                division = DivisionHalf('division-%s'%str(divId), teamL1, teamL2)
            else:
                raise Exception("Can't have more than two pools in the same division (%s)."%(', '.join(map(str,poolS))) )

            for team in teamL :
                team.division = division
            divL.append( division )

        self.league = League( divL )
        self.loadLeague( self.league )
Exemple #4
0
def parseSeason(teamlist: TeamList,
                gamelist: GameList,
                prev_leagues,
                filename,
                leaguename,
                leagueyear,
                initial=False,
                is_lg=True):

    league = League(leaguename, leagueyear)

    default = (PPG, PPG) if initial else season_map.default_quality(
        league, prev_leagues)

    with open(filename) as games_in:

        # Open csv dicitonary reader and discard header
        game_rdr = csv.reader(games_in)
        row = next(game_rdr)

        table_formats = set([])
        if row == ['Wk', 'Day', 'Date', 'Time', 'Home', 'Score', 'Away', 'Attendance', 'Venue', 'Referee', 'Match Report', 'Notes'] or \
                row == ['Round', 'Day', 'Date', 'Time', 'Home', 'Score', 'Away', 'Attendance', 'Venue', 'Referee', 'Match Report', 'Notes']:
            pass
        elif row == [
                'Wk', 'Day', 'Date', 'Time', 'Home', 'xG', 'Score', 'xG',
                'Away', 'Attendance', 'Venue', 'Referee', 'Match Report',
                'Notes'
        ]:
            table_formats = {"XG"}
        elif row == [
                'Round', 'Wk', 'Day', 'Date', 'Time', 'Home', 'Score', 'Away',
                'Attendance', 'Venue', 'Referee', 'Match Report', 'Notes'
        ]:
            table_formats = {"Round"}
        elif row == [
                'Round', 'Wk', 'Day', 'Date', 'Time', 'Home', 'xG', 'Score',
                'xG', 'Away', 'Attendance', 'Venue', 'Referee', 'Match Report',
                'Notes'
        ]:
            table_formats = {"XG", "Round"}
        else:
            raise RuntimeError(
                "Unable to parse table with header row: {}".format(row))

        for row in game_rdr:

            if "XG" in table_formats:
                if "Round" in table_formats:
                    rg_season, gamedate, homename, homexg, score, awayxg, awayname = row[
                        0], row[3], row[5], row[6], row[7], row[8], row[9]
                else:
                    gamedate, homename, homexg, score, awayxg, awayname = row[
                        2], row[4], row[5], row[6], row[7], row[8]
                    rg_season = None
            else:
                if "Round" in table_formats:
                    rg_season, gamedate, homename, score, awayname = row[
                        0], row[3], row[5], row[6], row[7]
                    homexg = awayxg = None
                else:
                    gamedate, homename, score, awayname = row[2], row[4], row[
                        5], row[6]
                    homexg = awayxg = rg_season = None

            if leaguename in ["champs"]:
                homename = " ".join(homename.split(" ")[:-1])
                awayname = " ".join(awayname.split(" ")[1:])

            try:
                date = datetime.datetime.strptime(gamedate, "%Y-%m-%d").date()
            except:
                continue

            hometeam = teamlist.getOrAdd(homename, default, is_lg)
            awayteam = teamlist.getOrAdd(awayname, default, is_lg)

            # parse scores if they exist
            try:
                homescore, awayscore = score.split('–')
                homescore, awayscore = int(homescore), int(awayscore)
            except:
                homescore = awayscore = None

            # parse home/away xg if they exist; otherwise make them None

            if homexg and awayxg:
                try:
                    home_xg, away_xg = float(homexg), float(awayxg)
                except:
                    print("Error in row with xg values", "/n", row)
            else:
                home_xg = away_xg = None

            # Make this a game
            lg = EXTRA_LEAGUE if is_lg and rg_season and rg_season != "Regular Season" else league
            game = Game(date, lg, hometeam, awayteam)
            if not (homescore is None):
                game.score(homescore, awayscore, home_xg, away_xg)

            # Add game to list of all games
            gamelist.add(game)

    return teamlist, league, gamelist
class ConfigLoader:
    def __init__(self, fileName):

        self.parserD = {
            DATE: self.parseDate,
            TIME: parseTime,
            FNAME: identity,
            STADIUM: identity,
            'action': identity,
            TIME_MAX: parseTime,
            TIME_MIN: parseTime,
            TEAM: self.parseTeam,
            }

        self.dateSrv = ObjSrv()

        self.wb = xlrd.open_workbook(fileName)

        self.loadGeneralConf()
        self.parseLeague()
        self.getGroups()
        self.getFieldL()
        self.getRestriction()
        self.getTeamGrpD()
        self.parseUniformity()

    def parseDate(self, date):
        if isinstance(date, datetime.date):
            d = Date(date.year, date.month, date.day)
        else:
            month, day, year = date.split('/', 2)
            d = Date(int(year), int(month), int(day))
        return self.dateSrv[d]

    def parseTeam(self, teamName):
        if isinstance(teamName, Team):
            team = teamName
        else:
            team = Team(teamName)

        return self.teamSrv[team]

    def loadLeague(self, league):
        self.divSrv = ObjSrv()
        self.teamSet = set()
        for division in league.divisionL:
            division = self.divSrv[division]
            for team in division.teamL:
                self.teamSet.add(team)

    def xl2py(self, val, fmt, strip=False ):
        if fmt == xlrd.XL_CELL_DATE:
            dateTuple = xlrd.xldate_as_tuple(val, self.wb.datemode)
            if dateTuple[3:] == (0,0,0):
                return datetime.date( *dateTuple[:3] )
            elif dateTuple[:3] == (0,0,0):
                return datetime.time( *dateTuple[3:] )
            else:
                return datetime.datetime( *dateTuple  )
        elif fmt == xlrd.XL_CELL_NUMBER:
            return val
        elif fmt == xlrd.XL_CELL_TEXT:
            if strip: val = val.strip()
            return val
        elif fmt == xlrd.XL_CELL_EMPTY:
            return None
        else:
            raise Exception( 'Unknown format %d'%fmt )

    def getRow( self, sh, idx, strip = False ):
        valL = []
        for val, fmt  in zip( sh.row_values(idx), sh.row_types(idx)  ):
            valL.append( self.xl2py( val, fmt, strip ) )
        return valL

    def getGroups( self ):

        sh = self.wb.sheet_by_name(u'groupes')
        groupD = {}

        for division in self.divSrv.objD.values():
            groupD[ '<%s>'%division.name ] = (TEAM,division.teamL)

        for i in range(1,sh.nrows):
            valL = self.getRow( sh, i, True )
            type_ = valL[0]
            name = valL[1]

            if type_ not in typeL:
                raise ConfigException("%s n'est pas un type valide. Les valeurs possibles sont : %s."%(type_, ', '.join(typeL)) )
            if not isGroupName(name):
                raise ConfigException("Un nom de groupe doit commencer par '<' et terminer par '>', ce qui n'est pas le cas de :%s"%name)

            itemL = []
            for val in valL[2:]:
                if val is not None: itemL.append( val )

            groupD[name] = (type_,itemL)


        self.groupD = groupD

    def expand( self, field, type_ ):
        if field is None: return None
        if not isinstance(field, (str, unicode)):
            valL = [field]
        else:
            if isGroupName( field ) and field in self.groupD:
                (type__, valL ) = self.groupD[ field ]
                if type__ != type_:
                    raise Exception("Vous avez utilisé un groupe de type %s dans un champ de type %s"%(type__,type_) )
            elif ',' in field:
                valL = [ val.strip() for val in field.split( ',' ) ]
            else:
                valL = [field]

        return [ self.parserD[type_]( val ) for val in valL ]

    def expandAll( self, valL, type2idx, typeL ):
        valLL = []
        for type_ in typeL:
            idx = type2idx[type_]
            valLL.append( self.expand( valL[idx], type_ ) )
        return valLL

    def getRestriction(self):
        sh = self.wb.sheet_by_name(RESTR)

        typeL, type2idx = self.getType( sh )

        restrD = {}

        self.teamSrv.lock = True
        self.dateSrv.lock = True

        for i in range(1,sh.nrows):
            valL = self.getRow( sh, i, True )
            include = signD[ str(valL[0]).strip() ]
            value = valL[1]

            teamL, dateL = self.expandAll( valL,type2idx,(TEAM,DATE) )
            timeMinL, timeMaxL, stadiumL, fNameL = self.expandAll( valL,type2idx,(TIME_MIN,TIME_MAX,STADIUM,FNAME) )



            if dateL is None:
                dateL = self.dateSrv.objD.values()

            for team in teamL:
                for date in dateL:
                    restr = Restriction( include, value, team, date )
                    if timeMinL is not None: restr.timeMin  = parseTime(timeMinL[0])
                    if timeMaxL is not None: restr.timeMax  = parseTime(timeMaxL[0])
                    if stadiumL is not None: restr.stadiumS = set( stadiumL )
                    if fNameL   is not None: restr.fNameS   = set( fNameL )
                    try:                restrD[ (team,date) ].append( restr )
                    except KeyError :   restrD[ (team,date) ] = [restr]



        self.restrD = restrD

    def getType(self, sh ):
        typeL = self.getRow( sh, 0, True )
        typeL = [ str(type_) for type_ in typeL ]
        type2idx = dict(  zip( typeL, range(len(typeL)) )  )

        return typeL, type2idx

    def getFieldL(self):
        sh = self.wb.sheet_by_name(u'terrains')
        typeL, _type2idx = self.getType(sh)

        fieldSet = set()
        for i in range(1, sh.nrows):
            valL = self.getRow(sh, i, True)
            action = str(valL[0]).strip()
            fieldPropLL = [self.expand(val, type_) for val, type_ in zip(valL[1:], typeL[1:])]
            subSet = set([fieldProp for fieldProp in itertools.product(*fieldPropLL)])

            if action == '+':
                fieldSet.update(subSet)
            elif action == '-':
                fieldSet.difference_update(subSet)

        fieldL = list(fieldSet)
        fieldL.sort()

        dateL = list(set(list(zip( *fieldL))[1]))
        dateL.sort()

        self.fieldL = []
        for stadium, date, time, fName in fieldL:
            self.fieldL.append( Field( stadium, fName, time, date, self.matchDuration ) )

    def getTeamGrpD(self):
        sh = self.wb.sheet_by_name(TEAM_GROUP)
        teamGrpD = {}
        for i in range(1,sh.nrows):
            valL = self.getRow( sh, i, True )
            name = valL[0]
            pen = valL[1]
            teamL = []
            for teamName in valL[2:]:
                if teamName is not None:
                    team = self.parseTeam(teamName)
                    if team in self.teamSet:
                        teamL.append( team )
                    else:
                        print('Unknown team : %s' % str(team))

            teamGrpD[name] = (pen, teamL)

        self.teamGrpD = teamGrpD

    def parseLeague(self):
        sh = self.wb.sheet_by_name(LEAGUE)
        self.teamSrv = ObjSrv()
        header = self.getRow( sh, 0, True )
        unifGrpIdL = header[3:]
        print(unifGrpIdL)
        divD = {}
        for i in range(1,sh.nrows):
            valL = self.getRow( sh, i, True )
            try:
                div = int(valL[0])
            except ValueError:
                div = str(valL[0])

            pool = valL[1]
            team = self.parseTeam(valL[2])
            team.rank = i
            countL = [ int(e) for e in valL[3:] ]
            team.unifCountD = dict( zip(unifGrpIdL, countL ))
            if div not in divD:
                divD[ div ] = []
            divD[div].append( (pool, team ) )


        divL = []
        for divId, valL in iteritems(divD):
            poolL, teamL = zip( *valL )
            poolS = set(poolL)
            if len(poolS) == 1:
                division = Division('division-%s'%str(divId), teamL)
            elif len(poolS) == 2:
                pool1, pool2 = list(poolS)
                teamL1 = [ team for pool, team in valL if pool == pool1 ]
                teamL2 = [ team for pool, team in valL if pool == pool2 ]
                division = DivisionHalf('division-%s'%str(divId), teamL1, teamL2)
            else:
                raise Exception("Can't have more than two pools in the same division (%s)."%(', '.join(map(str,poolS))) )

            for team in teamL :
                team.division = division
            divL.append( division )

        self.league = League( divL )
        self.loadLeague( self.league )

    def parseUniformity(self):
        sh = self.wb.sheet_by_name(UNIF)
        unifL = []
        for i in range(1,sh.nrows):
            restr = Restriction(False, 1, None, None)
            key, pen, maxCount, timeMin, timeMax, stadium, field = self.getRow(sh, i, True)
            if stadium is not None : restr.stadiumS = set([stadium])
            if field is not None : restr.fNameS = set([field])
            restr.timeMin = parseTime(timeMin)
            restr.timeMax = parseTime(timeMax)
            unifL.append( (key, float(pen) / 2**maxCount, restr) )

        keySet = set(list(zip( *unifL))[0])
        for team in self.league.getTeamL():
            if hasattr( team, 'unifCountD'):
                for id_ in team.unifCountD.keys():
                    if id_ not in keySet:
                        print("Warning : %s not in [%s]" % (id_, ', '.join(list(keySet))))

        self.unifL = unifL

    def loadGeneralConf(self):
        sh = self.wb.sheet_by_name(CONF_SHEET)
        confD = {}
        for i in range(sh.nrows):
            key, val = self.getRow( sh, i, True )
            confD[ confKeyMap[key] ] = val

        self.matchDuration = parseTime( confD['matchDuration'] )
        self.nbMatch = int( confD['nbMatch'] )
        self.penDateFactor = confD['penDateFactor']

    def getConfig(self):
        config = Config(self.league, self.fieldL, self.restrD, self.teamGrpD, self.unifL,
             self.matchDuration, self.nbMatch, self.penDateFactor)
        return config
class ConfigLoader:
    def __init__(self, fileName):

        self.parserD = {
            DATE: self.parseDate,
            TIME: parseTime,
            FNAME: identity,
            STADIUM: identity,
            'action': identity,
            TIME_MAX: parseTime,
            TIME_MIN: parseTime,
            TEAM: self.parseTeam,
        }

        self.dateSrv = ObjSrv()

        self.wb = xlrd.open_workbook(fileName)

        self.loadGeneralConf()
        self.parseLeague()
        self.getGroups()
        self.getFieldL()
        self.getRestriction()
        self.getTeamGrpD()
        self.parseUniformity()

    def parseDate(self, date):
        if isinstance(date, datetime.date):
            d = Date(date.year, date.month, date.day)
        else:
            month, day, year = date.split('/', 2)
            d = Date(int(year), int(month), int(day))
        return self.dateSrv[d]

    def parseTeam(self, teamName):
        if isinstance(teamName, Team):
            team = teamName
        else:
            team = Team(teamName)

        return self.teamSrv[team]

    def loadLeague(self, league):
        self.divSrv = ObjSrv()
        self.teamSet = set()
        for division in league.divisionL:
            division = self.divSrv[division]
            for team in division.teamL:
                self.teamSet.add(team)

    def xl2py(self, val, fmt, strip=False):
        if fmt == xlrd.XL_CELL_DATE:
            dateTuple = xlrd.xldate_as_tuple(val, self.wb.datemode)
            if dateTuple[3:] == (0, 0, 0):
                return datetime.date(*dateTuple[:3])
            elif dateTuple[:3] == (0, 0, 0):
                return datetime.time(*dateTuple[3:])
            else:
                return datetime.datetime(*dateTuple)
        elif fmt == xlrd.XL_CELL_NUMBER:
            return val
        elif fmt == xlrd.XL_CELL_TEXT:
            if strip: val = val.strip()
            return val
        elif fmt == xlrd.XL_CELL_EMPTY:
            return None
        else:
            raise Exception('Unknown format %d' % fmt)

    def getRow(self, sh, idx, strip=False):
        valL = []
        for val, fmt in zip(sh.row_values(idx), sh.row_types(idx)):
            valL.append(self.xl2py(val, fmt, strip))
        return valL

    def getGroups(self):

        sh = self.wb.sheet_by_name(u'groupes')
        groupD = {}

        for division in self.divSrv.objD.values():
            groupD['<%s>' % division.name] = (TEAM, division.teamL)

        for i in range(1, sh.nrows):
            valL = self.getRow(sh, i, True)
            type_ = valL[0]
            name = valL[1]

            if type_ not in typeL:
                raise ConfigException(
                    "%s n'est pas un type valide. Les valeurs possibles sont : %s."
                    % (type_, ', '.join(typeL)))
            if not isGroupName(name):
                raise ConfigException(
                    "Un nom de groupe doit commencer par '<' et terminer par '>', ce qui n'est pas le cas de :%s"
                    % name)

            itemL = []
            for val in valL[2:]:
                if val is not None: itemL.append(val)

            groupD[name] = (type_, itemL)

        self.groupD = groupD

    def expand(self, field, type_):
        if field is None: return None
        if not isinstance(field, (str, unicode)):
            valL = [field]
        else:
            if isGroupName(field) and field in self.groupD:
                (type__, valL) = self.groupD[field]
                if type__ != type_:
                    raise Exception(
                        "Vous avez utilisé un groupe de type %s dans un champ de type %s"
                        % (type__, type_))
            elif ',' in field:
                valL = [val.strip() for val in field.split(',')]
            else:
                valL = [field]

        return [self.parserD[type_](val) for val in valL]

    def expandAll(self, valL, type2idx, typeL):
        valLL = []
        for type_ in typeL:
            idx = type2idx[type_]
            valLL.append(self.expand(valL[idx], type_))
        return valLL

    def getRestriction(self):
        sh = self.wb.sheet_by_name(RESTR)

        typeL, type2idx = self.getType(sh)

        restrD = {}

        self.teamSrv.lock = True
        self.dateSrv.lock = True

        for i in range(1, sh.nrows):
            valL = self.getRow(sh, i, True)
            include = signD[str(valL[0]).strip()]
            value = valL[1]

            teamL, dateL = self.expandAll(valL, type2idx, (TEAM, DATE))
            timeMinL, timeMaxL, stadiumL, fNameL = self.expandAll(
                valL, type2idx, (TIME_MIN, TIME_MAX, STADIUM, FNAME))

            if dateL is None:
                dateL = self.dateSrv.objD.values()

            for team in teamL:
                for date in dateL:
                    restr = Restriction(include, value, team, date)
                    if timeMinL is not None:
                        restr.timeMin = parseTime(timeMinL[0])
                    if timeMaxL is not None:
                        restr.timeMax = parseTime(timeMaxL[0])
                    if stadiumL is not None: restr.stadiumS = set(stadiumL)
                    if fNameL is not None: restr.fNameS = set(fNameL)
                    try:
                        restrD[(team, date)].append(restr)
                    except KeyError:
                        restrD[(team, date)] = [restr]

        self.restrD = restrD

    def getType(self, sh):
        typeL = self.getRow(sh, 0, True)
        typeL = [str(type_) for type_ in typeL]
        type2idx = dict(zip(typeL, range(len(typeL))))

        return typeL, type2idx

    def getFieldL(self):
        sh = self.wb.sheet_by_name(u'terrains')
        typeL, _type2idx = self.getType(sh)

        fieldSet = set()
        for i in range(1, sh.nrows):
            valL = self.getRow(sh, i, True)
            action = str(valL[0]).strip()
            fieldPropLL = [
                self.expand(val, type_)
                for val, type_ in zip(valL[1:], typeL[1:])
            ]
            subSet = set(
                [fieldProp for fieldProp in itertools.product(*fieldPropLL)])

            if action == '+':
                fieldSet.update(subSet)
            elif action == '-':
                fieldSet.difference_update(subSet)

        fieldL = list(fieldSet)
        fieldL.sort()

        dateL = list(set(list(zip(*fieldL))[1]))
        dateL.sort()

        self.fieldL = []
        for stadium, date, time, fName in fieldL:
            self.fieldL.append(
                Field(stadium, fName, time, date, self.matchDuration))

    def getTeamGrpD(self):
        sh = self.wb.sheet_by_name(TEAM_GROUP)
        teamGrpD = {}
        for i in range(1, sh.nrows):
            valL = self.getRow(sh, i, True)
            name = valL[0]
            pen = valL[1]
            teamL = []
            for teamName in valL[2:]:
                if teamName is not None:
                    team = self.parseTeam(teamName)
                    if team in self.teamSet:
                        teamL.append(team)
                    else:
                        print('Unknown team : %s' % str(team))

            teamGrpD[name] = (pen, teamL)

        self.teamGrpD = teamGrpD

    def parseLeague(self):
        sh = self.wb.sheet_by_name(LEAGUE)
        self.teamSrv = ObjSrv()
        header = self.getRow(sh, 0, True)
        unifGrpIdL = header[3:]
        print(unifGrpIdL)
        divD = {}
        for i in range(1, sh.nrows):
            valL = self.getRow(sh, i, True)
            try:
                div = int(valL[0])
            except ValueError:
                div = str(valL[0])

            pool = valL[1]
            team = self.parseTeam(valL[2])
            team.rank = i
            countL = [int(e) for e in valL[3:]]
            team.unifCountD = dict(zip(unifGrpIdL, countL))
            if div not in divD:
                divD[div] = []
            divD[div].append((pool, team))

        divL = []
        for divId, valL in iteritems(divD):
            poolL, teamL = zip(*valL)
            poolS = set(poolL)
            if len(poolS) == 1:
                division = Division('division-%s' % str(divId), teamL)
            elif len(poolS) == 2:
                pool1, pool2 = list(poolS)
                teamL1 = [team for pool, team in valL if pool == pool1]
                teamL2 = [team for pool, team in valL if pool == pool2]
                division = DivisionHalf('division-%s' % str(divId), teamL1,
                                        teamL2)
            else:
                raise Exception(
                    "Can't have more than two pools in the same division (%s)."
                    % (', '.join(map(str, poolS))))

            for team in teamL:
                team.division = division
            divL.append(division)

        self.league = League(divL)
        self.loadLeague(self.league)

    def parseUniformity(self):
        sh = self.wb.sheet_by_name(UNIF)
        unifL = []
        for i in range(1, sh.nrows):
            restr = Restriction(False, 1, None, None)
            key, pen, maxCount, timeMin, timeMax, stadium, field = self.getRow(
                sh, i, True)
            if stadium is not None: restr.stadiumS = set([stadium])
            if field is not None: restr.fNameS = set([field])
            restr.timeMin = parseTime(timeMin)
            restr.timeMax = parseTime(timeMax)
            unifL.append((key, float(pen) / 2**maxCount, restr))

        keySet = set(list(zip(*unifL))[0])
        for team in self.league.getTeamL():
            if hasattr(team, 'unifCountD'):
                for id_ in team.unifCountD.keys():
                    if id_ not in keySet:
                        print("Warning : %s not in [%s]" %
                              (id_, ', '.join(list(keySet))))

        self.unifL = unifL

    def loadGeneralConf(self):
        sh = self.wb.sheet_by_name(CONF_SHEET)
        confD = {}
        for i in range(sh.nrows):
            key, val = self.getRow(sh, i, True)
            confD[confKeyMap[key]] = val

        self.matchDuration = parseTime(confD['matchDuration'])
        self.nbMatch = int(confD['nbMatch'])
        self.penDateFactor = confD['penDateFactor']

    def getConfig(self):
        config = Config(self.league, self.fieldL, self.restrD, self.teamGrpD,
                        self.unifL, self.matchDuration, self.nbMatch,
                        self.penDateFactor)
        return config