spl/fpl_lib.py

from fpl import FPL
from fpl.utils import get_current_gameweek, position_converter
import aiohttp
import asyncio
from bson.objectid import ObjectId

class Team:
    def __init__(self, title, mongo, sfp=None):
        self.mongo = mongo

        self.title = title
        self.gks = []
        self.gks_n = 2

        self.defs = []
        self.defs_n = 5

        self.mids = []
        self.mids_n = 5

        self.fwds = []
        self.fwds_n = 3



    def set_players(self, players):
        self.players = players


    def get_players(self):
        temp = []
        if self.gks != None:
            for o in self.gks:
                temp.append(self.sfp.get_player(o))

        if self.defs != None:
            for o in self.defs:
                temp.append(self.sfp.get_player(o))

        if self.mids != None:
            for o in self.mids:
                temp.append(self.sfp.get_player(o))

        if self.fwds != None:
            for o in self.fwds:
                temp.append(self.sfp.get_player(o))

        return temp

    def remove_player(self, pid):
        p = self.sfp.get_player(pid)
        ps = self.pos_str(p)

        if ps == "Goalkeeper":
            self.gks.remove(pid)
        if ps == "Defender":
            self.defs.remove(pid)
        if ps == "Midfielder":
            self.mids.remove(pid)
        if ps == "Forward":
            self.fwds.remove(pid)

    def show_players_info(self):
        print(f"{self.name} players:")
        for p in self.players:
            print(f"{p}  gs = {p.goals_scored} tp = {p.total_points}")

        total = sum(p.goals_scored for p in self.players)
        print(f"Total Score => {total}")

    def manage_squad(self):
        self.select_gk()
        self.select_def()
        self.select_mid()
        self.select_fwd()

    def pos_str(self, player):
        return position_converter(player.element_type)

    def add_player(self, player):
        print(f"add player {player}")
        self.select_gk(player)
        self.select_def(player)
        self.select_mid(player)
        self.select_fwd(player)

    def select_gk(self, player):
        if len(self.gks) < self.gks_n:
            print(f"xxx {len(self.gks)}")
            if self.pos_str(player) == "Goalkeeper":
                print("Goal Keep")
                self.gks.append(player.id)
                print(self.gks)

    def select_def(self, player):
        if len(self.defs) < self.defs_n:
            if self.pos_str(player) == "Defender":
                self.defs.append(player.id)

    def select_mid(self, player):
        if len(self.mids) < self.mids_n:
            if self.pos_str(player) == "Midfielder":
                self.mids.append(player.id)

    def select_fwd(self, player):
        if len(self.fwds) < self.fwds_n:
            if self.pos_str(player) == "Forward":
                self.fwds.append(player.id)

    def set_starting(self):
        pass

    def transfer(self):
        pass

    def save(self):
        return  self.mongo.db.teams.update_one({"_id": self._id}, {'$set':{
            'title': self.title, 'gks': self.gks, 'defs': self.defs, 'mids': self.mids,
            'fwds': self.fwds
        }})

    def create(self):
        return  self.mongo.db.teams.insert_one({
            'name': self.name, 'gks': self.gks, 'defs': self.defs, 'mids': self.mids,
            'fwds': self.fwds
        })


    @classmethod
    def from_id(cls, oid, mongo=None):
        doc = mongo.db.teams.find_one({"_id": ObjectId(oid)})
        c = cls(None, mongo)
        c.init_db(doc)
        return c

    def init_db(self,  col):
        for f in ['title', 'gks', 'defs', 'mids', 'fwds', "_id"]:
            print(col)
            setattr(self, f, col.get(f, None))

        if self.gks == None:
            self.gks = []

        if self.defs == None:
            self.defs = []

        if self.mids == None:
            self.mids = []

        if self.fwds == None:
            self.fwds = []

class Leauge:
    def __init__(self, title, mongo=None):
        self.title = title
        self.mongo = mongo


    @classmethod
    def from_id(cls, oid, mongo=None):
        lg = mongo.db.lgs.find_one({"_id": ObjectId(oid)})
        print(f"lg = {lg}")
        c = cls(None, mongo)
        c.init_db(lg)
        return c

    def init_db(self,  col):
        self.title = col.get('title', None)
        self._teams = col.get('teams', [])
        self._id = col.get('_id',None)

    @property
    def teams(self):
        return self.mongo.db.teams.find({"_id": {"$in": self._teams}})

    def save(self):

        self.mongo.db.lgs.update_one({"_id": self._id}, {
            '$set': {'title': self.title, 'teams': self._teams}
        })

    def create(self):

        return  self.mongo.db.lgs.insert_one({
            'title': self.title, 'teams': []
        })

    def add_team(self, team_id):
        self._teams.append(ObjectId(team_id))

    def remove_team(self, team_id):
        self._teams.remove(ObjectId(team_id))


class SFL:
    def __init__(self, name,mongo=None):
        self.name = name
        self.mongo = mongo

    async def _setup(self):
        async with aiohttp.ClientSession() as session:
            self.session = session
            self.fpl = FPL(self.session)
            self.players = await self.fpl.get_players()
            #return self

    def setup(self):
        asyncio.set_event_loop(asyncio.SelectorEventLoop())
        asyncio.get_event_loop().run_until_complete(self._setup())

    def get_player(self, pid):
        asyncio.set_event_loop(asyncio.SelectorEventLoop())
        return asyncio.get_event_loop().run_until_complete(self._get_player(pid))

    async def _get_player(self, pid):
        return await self.fpl.get_player(pid)

    def search_player(self, name):
        results = [{'info':  str(x), 'id': x.id } for x in self.players
                   if (name in x.web_name.lower()) or ( name  in position_converter(x.element_type).lower())]
        return results


async def main():
    async with aiohttp.ClientSession() as session:
        fpl = FPL(session)
        gameweek = await fpl.get_gameweek(1)

        cg = await get_current_gameweek(fpl.session)
        gameweek2 = await fpl.get_gameweek(cg)
        gameweek3 = await fpl.get_gameweek(cg+1)

        players = await fpl.get_players()

    #print("==== players ====")
    '''
    for p in players[:10]:
        print(dir(p))
    '''


    #print(gameweek.name)
    #print(cg)
    #print(dir(gameweek))
    print(gameweek2)
    print("======================")
    #print(gameweek3)

    team = Team("Tum Team")
    team.set_players(players[:15])
    team.show_players_info()

if __name__ == "__main__":
    asyncio.get_event_loop().run_until_complete(main())