Mature Cards and Players

in_game/gameplay_models.py

@@ -188,6 +188,26 @@ class PlayerBase(SQLModel):
     mlbplayer_id: int | None = Field(default=None)
     created: datetime.datetime | None = Field(default=datetime.datetime.now())
 
+    @property
+    def p_card_url(self):
+        if 'pitching' in self.image:
+            return self.image
+        elif self.image2 is not None and 'pitching' in self.image2:
+            return self.image2
+        else:
+            logging.error(f'gameplay_models - PlayerBase - pitching card url not found for {self.id}. {self.description} {self.name}')
+            return self.image
+    
+    @property
+    def b_card_url(self):
+        if 'batting' in self.image:
+            return self.image
+        elif self.image2 is not None and 'batting' in self.image2:
+            return self.image2
+        else:
+            logging.error(f'gameplay_models - PlayerBase - batting card url not found for {self.id}. {self.description} {self.name}')
+            return self.image
+
 
 class Player(PlayerBase, table=True):
     cardset: Cardset = Relationship(back_populates='players')
@@ -213,6 +233,7 @@ def player_description(player: Player = None, player_dict: dict = None) -> str:
 
 
 async def get_player_or_none(session: Session, player_id: int, skip_cache: bool = False) -> Player | None:
+    logging.info(f'gameplay_models - get_player_or_none - player_id: {player_id}')
     if not skip_cache:
         this_player = session.get(Player, player_id)
 
@@ -227,6 +248,7 @@ async def get_player_or_none(session: Session, player_id: int, skip_cache: bool
                 session.commit()
     
     def cache_player(json_data: dict) -> Player:
+        logging.info(f'gameplay_models - get_player_or_none - cache_player - caching player data: {json_data}')
         valid_player = PlayerBase.model_validate(json_data, from_attributes=True)
         db_player = Player.model_validate(valid_player)
         session.add(db_player)
@@ -245,6 +267,15 @@ async def get_player_or_none(session: Session, player_id: int, skip_cache: bool
     return None
 
 
+def get_player_id_from_dict(json_data: dict) -> int:
+    if 'player_id' in json_data:
+        return json_data['player_id']
+    elif 'id' in json_data:
+        return json_data['id']
+    err = 'Player ID could not be extracted from json data'
+    logging.error(f'{err}: {json_data}')
+    raise KeyError(err)
+
 
 class CardBase(SQLModel):
     id: int | None = Field(default=None, primary_key=True)
@@ -260,15 +291,34 @@ class Card(CardBase, table=True):
     lineups: list['Lineup'] = Relationship(back_populates='card', cascade_delete=True)
 
 
-async def get_or_create_ai_card(session: Session, player: Player, team: Team) -> Card:
+async def get_or_create_ai_card(session: Session, player: Player, team: Team, skip_cache: bool = False, dev_mode: bool = False) -> Card:
     if not team.is_ai:
         err = f'Cannot create AI cards for human teams'
         logging.error(f'gameplay_models - get_or_create_ai_card: {err}')
         raise TypeError(err)
+    
+    logging.info(f'gameplay_models - get_or_create_ai_card - player.id: {player.id} / team.id: {team.id}')
+    if not skip_cache:
+        c_query = session.exec(select(Card).where(Card.player == player, Card.team == team)).all()
 
-    async def pull_card(player, team):
-        c_query = await db_get('cards', params=[('team_id', team.id), ('player_id', player.id)])
+        if len(c_query) > 0:
+            this_card = c_query[0]
+            logging.info(f'we found a cached card: {this_card} / created: {this_card.created}')
+            tdelta = datetime.datetime.now() - this_card.created
+            logging.debug(f'tdelta: {tdelta}')
+            if tdelta.total_seconds() < CACHE_LIMIT:
+                return this_card
+            else:
+                session.delete(this_card)
+                session.commit()
+
+    async def pull_card(p: Player, t: Team):
+        c_query = await db_get('cards', params=[('team_id', t.id), ('player_id', p.id)])
         if c_query['count'] > 0:
+            json_data = c_query['cards'][0]
+            logging.info(f'gameplay_models - get_or_create_ai_card - pull_card - caching json_data: {json_data}')
+            json_data['team_id'] = json_data['team']['id']
+            json_data['player_id'] = get_player_id_from_dict(json_data['player'])
             valid_card = CardBase.model_validate(c_query['cards'][0], from_attributes=True)
             db_card = Card.model_validate(valid_card)
             session.add(db_card)
@@ -284,6 +334,13 @@ async def get_or_create_ai_card(session: Session, player: Player, team: Team) ->
 
     logging.info(f'gameplay_models - get_or_create_ai_card: creating {player.description} {player.name} card for {team.abbrev}')
 
+    if dev_mode:
+        this_card = Card(player=player, team=team)
+        session.add(this_card)
+        session.commit()
+        session.refresh(this_card)
+        return this_card
+
     await db_post(
         'cards', 
         payload={'cards': [
@@ -325,10 +382,16 @@ async def get_card_or_none(session: Session, card_id: int, skip_cache: bool = Fa
     c_query = await db_get('cards', object_id=card_id)
     if c_query is not None:
         c_query['team_id'] = c_query['team']['id']
-        if 'player_id' in c_query['player']:
-            c_query['player_id'] = c_query['player']['player_id']
-        else:
-            c_query['player_id'] = c_query['player']['id']
+        c_query['player_id'] = get_player_id_from_dict(c_query['player'])
+        
+        this_player = await get_player_or_none(session, player_id=c_query['player_id'])
+        this_team = await get_team_or_none(session, team_id=c_query['team_id'])
+
+        if this_player is None:
+            raise LookupError(f'Player ID {c_query["player_id"]} not found during card check')
+        if this_team is None:
+            raise LookupError(f'Team ID {c_query["team_id"]} not found during card check')
+
         return cache_card(c_query)
     
     return None

tests/gameplay_models/test_card_model.py

@@ -1,7 +1,7 @@
 import datetime
 from sqlmodel import Session
 
-from in_game.gameplay_models import CACHE_LIMIT, Card, select, get_card_or_none
+from in_game.gameplay_models import CACHE_LIMIT, Card, Player, Team, select, get_card_or_none, get_or_create_ai_card
 from factory import session_fixture
 
 
@@ -19,12 +19,43 @@ def test_create_card(session: Session):
     assert card_2.team_id == 400
 
 
+async def test_get_or_create_ai_card(session: Session):
+    cached_card = session.get(Card, 1)
+
+    assert cached_card.player_id == 1
+    assert cached_card.team_id == 31
+
+    this_player = session.get(Player, 1)
+    this_team = session.get(Team, 31)
+    new_card_1 = await get_or_create_ai_card(session, this_player, this_team)
+
+    assert cached_card.created == new_card_1.created
+
+    new_card_2 = await get_or_create_ai_card(
+        session,
+        player=session.get(Player, 30),
+        team=this_team,
+        dev_mode=True
+    )
+
+    assert new_card_2.id == 42
+
+
 async def test_get_card_or_none(session: Session):
     card_1 = session.get(Card, 1)
     new_card_1 = await get_card_or_none(session, card_id=card_1.id)
 
     assert card_1.created == new_card_1.created
-
+    
+    assert session.get(Player, 538) is None
+    assert session.get(Team, 55) is None
+    
     new_card_2 = await get_card_or_none(session, card_id=55555)
+    print(f'new_card_2: {new_card_2}\nplayer: {new_card_2.player}\nteam: {new_card_2.team}')
+    
     assert new_card_2 is not None
+    assert new_card_2.player_id == 538
+    assert new_card_2.team_id == 55
+    assert session.get(Player, 538) is not None
+    assert session.get(Team, 55) is not None
 

tests/gameplay_models/test_player_model.py

@@ -1,7 +1,8 @@
 import datetime
+import pytest
 from sqlmodel import Session
 
-from in_game.gameplay_models import CACHE_LIMIT, Player, player_description, select, get_player_or_none
+from in_game.gameplay_models import CACHE_LIMIT, Player, player_description, select, get_player_or_none, get_player_id_from_dict
 from factory import session_fixture
 
 
@@ -48,3 +49,11 @@ def test_player_description(session: Session):
     assert player_description(player_dict=player_dict) == f'Live Player 1'
 
 
+def test_player_id_from_dict(session: Session):
+    assert get_player_id_from_dict({'player_id': 1337}) == 1337
+    assert get_player_id_from_dict({'id': 6969}) == 6969
+
+    with pytest.raises(KeyError) as exc_info:
+        get_player_id_from_dict({})
+
+    assert str(exc_info) == "<ExceptionInfo KeyError('Player ID could not be extracted from json data') tblen=2>"