Team2-Virtual-Pet 0.1.0__py3-none-any.whl

package/__init__.py

@@ -0,0 +1,6 @@
+from .energy import drain_energy, restore_energy
+from .health import update_health, wellness
+from .history import get_history, record_event
+from .save_load import load_pet, save_pet
+from .death import check_death
+from .diagnosis import diagnose_pet, recommend_action

package/death.py

@@ -0,0 +1,52 @@
+from datetime import datetime, timedelta, timezone
+
+from .pet import check_pet
+from .health import DEATH_HEALTH
+
+INACTIVE_DAYS = 7
+
+
+def check_death(pet, last_opened=None, now=None):
+    #Check if the pet has died from low health or inactivity.
+
+    check_pet(pet, "health")
+
+    if "alive" not in pet or not isinstance(pet["alive"], bool):
+        raise TypeError("alive must be a bool")
+
+    
+    if not pet["alive"]:
+        return True
+
+    
+    if pet["health"] <= DEATH_HEALTH:
+        pet["alive"] = False
+        return True
+
+    
+    if last_opened is not None:
+        if not isinstance(last_opened, str):
+            raise TypeError("last_opened must be a string")
+
+        try:
+            last_date = datetime.fromisoformat(last_opened)
+        except ValueError:
+            raise ValueError("last_opened must be a valid date")
+
+        if now is None:
+            now = datetime.now(timezone.utc)
+
+        if not isinstance(now, datetime):
+            raise TypeError("now must be a datetime")
+
+        if last_date.tzinfo is None or now.tzinfo is None:
+            raise ValueError("dates must include a timezone")
+
+        if last_date > now:
+            raise ValueError("last_opened cannot be in the future")
+
+        if now - last_date >= timedelta(days=INACTIVE_DAYS):
+            pet["alive"] = False
+            return True
+
+    return False

package/diagnosis.py

@@ -0,0 +1,71 @@
+
+from .health import HEALTHY_HUNGER, HEALTHY_STAT, DEATH_HEALTH
+from .pet import STATS, check_pet
+
+
+def _validate_pet(pet):
+    """Validate all pet stats and the alive flag."""
+    for stat in STATS:
+        check_pet(pet, stat)
+
+    if not isinstance(pet.get("alive"), bool):
+        raise TypeError("alive must be a bool")
+
+
+def diagnose_pet(pet):
+    """Return a list of health issues affecting the pet."""
+    _validate_pet(pet)
+
+    if not pet["alive"] or pet["health"] <= DEATH_HEALTH:
+        return ["Your pet has passed away."]
+
+    issues = []
+
+    if pet["hunger"] > HEALTHY_HUNGER:
+        issues.append("Your pet is hungry. Feed it!")
+
+    if pet["energy"] < HEALTHY_STAT:
+        issues.append("Your pet is tired. Let it rest!")
+
+    if pet["hygiene"] < HEALTHY_STAT:
+        issues.append("Your pet is dirty. Give it a bath!")
+
+    if pet["happiness"] < HEALTHY_STAT:
+        issues.append("Your pet is sad. Play with it!")
+
+    if pet["health"] <= 30:
+        issues.append("Your pet is critically unhealthy!")
+
+    if not issues:
+        return ["Your pet is healthy and happy!"]
+
+    return issues
+
+
+def recommend_action(pet):
+    """Recommend care for the pet's most urgent need."""
+    _validate_pet(pet)
+
+    if not pet["alive"] or pet["health"] <= DEATH_HEALTH:
+        return "Your pet has passed away."
+
+    needs = {
+        "feed": max(pet["hunger"] - HEALTHY_HUNGER, 0),
+        "rest": max(HEALTHY_STAT - pet["energy"], 0),
+        "clean": max(HEALTHY_STAT - pet["hygiene"], 0),
+        "play": max(HEALTHY_STAT - pet["happiness"], 0),
+    }
+
+    most_urgent = max(needs, key=needs.get)
+
+    if needs[most_urgent] == 0:
+        return "Your pet is healthy! Keep taking good care of it."
+
+    recommendations = {
+        "feed": "Feed your pet to reduce its hunger.",
+        "rest": "Let your pet rest to restore energy.",
+        "clean": "Give your pet a bath to improve hygiene.",
+        "play": "Play with your pet to improve happiness.",
+    }
+
+    return recommendations[most_urgent]

package/display.py

@@ -0,0 +1,56 @@
+
+"""Display the Tamagotchi as an ASCII cat."""
+
+HAPPY_LEVEL = 70
+NEUTRAL_LEVEL = 35
+DEATH_HEALTH = 10
+
+
+def show_pet(pet):
+    """Return the Tamagotchi's appearance based on its stats."""
+
+    if not isinstance(pet, dict):
+        raise TypeError("pet must be a dictionary")
+
+    for stat in ("happiness", "health", "alive"):
+        if stat not in pet:
+            raise TypeError(f"pet must have a '{stat}' key")
+
+    happiness = pet["happiness"]
+    health = pet["health"]
+    alive = pet["alive"]
+
+    if type(happiness) is not int:
+        raise TypeError("happiness must be an int")
+    if happiness < 0 or happiness > 100:
+        raise ValueError("happiness must be between 0 and 100")
+
+    if type(health) is not int:
+        raise TypeError("health must be an int")
+    if health < 0 or health > 100:
+        raise ValueError("health must be between 0 and 100")
+
+    if not isinstance(alive, bool):
+        raise TypeError("alive must be a bool")
+
+    if not alive or health <= DEATH_HEALTH:
+        face = "( x.x )"
+        mouth = "> _ <"
+    elif happiness >= HAPPY_LEVEL:
+        face = "( ^.^ )"
+        mouth = "> w <"
+    elif happiness >= NEUTRAL_LEVEL:
+        face = "( o.o )"
+        mouth = "> - <"
+    else:
+        face = "( ;.; )"
+        mouth = "> n <"
+
+    cat = (
+        "     /\\_/\\\n"
+        f"    {face}\n"
+        f"     {mouth}"
+    )
+
+    return cat
+

package/energy.py

@@ -0,0 +1,43 @@
+
+from .history import record_event
+from .pet import check_count, check_pet, clamp
+
+REST_ENERGY = 20
+
+
+def drain_energy(pet, amount):
+    """Decrease energy by a given amount."""
+    check_pet(pet, "energy")
+    check_count(amount, "amount")
+
+    before = pet["energy"]
+    pet["energy"] = clamp(before - amount)
+
+    if pet["energy"] != before:
+        record_event(
+            pet, "stat",
+            stat="energy",
+            before=before,
+            after=pet["energy"]
+        )
+
+    return pet["energy"]
+
+
+def restore_energy(pet, amount=REST_ENERGY):
+    """Restore energy by a given amount."""
+    check_pet(pet, "energy")
+    check_count(amount, "amount")
+
+    before = pet["energy"]
+    pet["energy"] = clamp(before + amount)
+
+    if pet["energy"] != before:
+        record_event(
+            pet, "stat",
+            stat="energy",
+            before=before,
+            after=pet["energy"]
+        )
+
+    return pet["energy"]

package/happy.py

@@ -0,0 +1,72 @@
+from .pet import clamp, check_count, check_pet
+from .history import record_event
+from .energy import drain_energy
+
+
+def play(pet, name, play_type):
+    """Uses user input to select which type of play, increases happiness accordingly"""
+
+    # Invalid arguments
+    if play_type is None or not isinstance(play_type, str):
+        return "\033[1mThat is not a valid play type.\033[0m"
+
+    # Valid arguments
+    if play_type == "1":  # Pet
+        before = pet["happiness"]
+        increase_happiness(pet, 15)
+        drain_energy(pet, 5)
+        record_event(
+            pet,
+            "play",
+            detail="pet",
+            stat="happiness",
+            before=before,
+            after=pet["happiness"],
+        )
+        return f"\033[1m*You pet {name}, they love it!*\033[0m"
+
+    elif play_type == "2":  # Catch
+        before = pet["happiness"]
+        increase_happiness(pet, 10)
+        drain_energy(pet, 10)
+        record_event(
+            pet,
+            "play",
+            detail="catch",
+            stat="happiness",
+            before=before,
+            after=pet["happiness"],
+        )
+        return f"\033[1m*You throw a ball to {name}, they catch it and happily bring it back to you!*\033[0m"
+
+    elif play_type == "3":  # Walk
+        before = pet["happiness"]
+        increase_happiness(pet, 5)
+        drain_energy(pet, 15)
+        record_event(
+            pet,
+            "play",
+            detail="walk",
+            stat="happiness",
+            before=before,
+            after=pet["happiness"],
+        )
+        return f"\033[1m*You take {name} on a walk, they smile the entire time!*\033[0m"
+
+    else:
+        return "\033[1mThat is not a valid play type.\033[0m"
+
+
+def increase_happiness(pet, happiness_change):
+    """Increment pet happiness by specified amount."""
+    check_pet(pet, "happiness")
+    check_count(happiness_change, "happiness_change")
+    pet["happiness"] = clamp(pet["happiness"] + happiness_change)
+    return pet["happiness"]
+
+
+def decrease_happiness(pet):
+    """Decrement pet happiness by 10 for every non-play interaction (feed, clean, rest)."""
+    check_pet(pet, "happiness")
+    pet["happiness"] = clamp(pet["happiness"] - 10)
+    return pet["happiness"]

package/health.py

@@ -0,0 +1,59 @@
+from .history import record_event
+from .pet import MAX_STAT, STATS, check_count, check_pet, clamp
+
+HEALTHY_STAT = 60  # baseline health stat level
+HEALTHY_HUNGER = 40  # hunger at or below this is healthy
+SICK_WELLNESS = 50  # wellness below this starts hurting health
+DAMAGE_DIVISOR = 5  # every 5 wellness points below SICK_WELLNESS costs 1 health
+REGEN_PER_TICK = 2
+DEATH_HEALTH = 10  # pet dies at or below this
+
+
+def _check_full_pet(pet):
+    for stat in STATS:
+        check_pet(pet, stat)
+
+
+def _all_healthy(pet):
+    return pet["hunger"] <= HEALTHY_HUNGER and all(
+        pet[stat] >= HEALTHY_STAT for stat in ("energy", "hygiene", "happiness")
+    )
+
+
+def wellness(pet):
+    """Average of hunger, energy, hygiene and happiness, from 0 to 100."""
+    _check_full_pet(pet)
+    scores = [
+        MAX_STAT - pet["hunger"],
+        pet["energy"],
+        pet["hygiene"],
+        pet["happiness"],
+    ]
+    return sum(scores) / len(scores)
+
+
+def update_health(pet, ticks=1):
+    """Apply `ticks` rounds of health change and return the new health."""
+    _check_full_pet(pet)
+    check_count(ticks, "ticks")
+
+    for _ in range(ticks):
+        if not pet.get("alive", True):
+            break
+        if _all_healthy(pet):
+            change = REGEN_PER_TICK
+        else:
+            change = -int(max(SICK_WELLNESS - wellness(pet), 0) // DAMAGE_DIVISOR)
+        before = pet["health"]
+        pet["health"] = clamp(pet["health"] + change)
+        if pet["health"] != before:
+            record_event(
+                pet,
+                "stat",
+                stat="health",
+                before=before,
+                after=pet["health"],
+            )
+        if pet["health"] <= DEATH_HEALTH:
+            pet["alive"] = False
+    return pet["health"]

package/history.py

@@ -0,0 +1,60 @@
+"""Record what happened to a pet and read those events back."""
+
+from .pet import MAX_STAT, MIN_STAT, STATS, check_count
+
+ACTIONS = ("feed", "play", "clean", "stat")
+
+
+def _check_bound(value, name):
+    """Raise unless value is an int stat, or None."""
+    if value is None:
+        return
+    if isinstance(value, bool) or not isinstance(value, int):
+        raise TypeError(f"{name} must be an int")
+    if value < MIN_STAT or value > MAX_STAT:
+        raise ValueError(f"{name} must be between {MIN_STAT} and {MAX_STAT}")
+
+
+def record_event(pet, action, detail=None, stat=None, before=None, after=None):
+    """Append one event and return a copy of it."""
+    if not isinstance(pet, dict):
+        raise TypeError("pet must be a dict")
+    if action not in ACTIONS:
+        raise ValueError("action must be feed, play, clean, or stat")
+    if detail is not None and not isinstance(detail, str):
+        raise TypeError("detail must be a string")
+    if stat is not None and stat not in STATS:
+        raise ValueError("stat must be energy, hunger, hygiene, happiness, or health")
+    if action == "stat" and stat is None:
+        raise ValueError("stat is required when action is 'stat'")
+    _check_bound(before, "before")
+    _check_bound(after, "after")
+    if (before is None) != (after is None):
+        raise ValueError("before and after must both be set or both be omitted")
+
+    event = {
+        "action": action,
+        "detail": detail,
+        "stat": stat,
+        "before": before,
+        "after": after,
+    }
+    history = pet.setdefault("history", [])
+    if not isinstance(history, list):
+        raise TypeError("history must be a list")
+    history.append(event)
+    return dict(event)
+
+
+def get_history(pet, limit):
+    """Return the most recent events, oldest of that slice first."""
+    if not isinstance(pet, dict):
+        raise TypeError("pet must be a dict")
+    check_count(limit, "limit")
+
+    history = pet.get("history", [])
+    if not isinstance(history, list):
+        raise TypeError("history must be a list")
+    if limit == 0:
+        return []
+    return [dict(event) for event in history[-limit:]]

package/hunger.py

@@ -0,0 +1,25 @@
+"""Update the pet's hunger based on inputs since it was fed."""
+
+from .history import record_event
+from .pet import MIN_STAT, check_count, check_pet, clamp
+
+HUNGER_PER_INPUT = 5
+
+
+def feed(pet):
+    """Set hunger to zero and record a feed event."""
+    check_pet(pet, "hunger")
+    before = pet["hunger"]
+    pet["hunger"] = MIN_STAT
+    record_event(pet, "feed", stat="hunger", before=before, after=pet["hunger"])
+    return pet["hunger"]
+
+
+def update_hunger(pet, inputs_since_fed):
+    """Raise hunger as inputs occur after the pet was fed."""
+    check_pet(pet, "hunger")
+    check_count(inputs_since_fed, "inputs_since_fed")
+
+    before = pet["hunger"]
+    pet["hunger"] = clamp(inputs_since_fed * HUNGER_PER_INPUT)
+    return pet["hunger"]

package/hygiene.py

@@ -0,0 +1,27 @@
+"""Update the pet's hygiene based on commits behind origin."""
+
+from .history import record_event
+from .pet import MAX_STAT, check_count, check_pet, clamp
+
+HYGIENE_LOSS_PER_COMMIT_BEHIND = 10
+
+
+def clean(pet):
+    """Set hygiene to full and record a clean event."""
+    check_pet(pet, "hygiene")
+    before = pet["hygiene"]
+    pet["hygiene"] = MAX_STAT
+    record_event(pet, "clean", stat="hygiene", before=before, after=pet["hygiene"])
+    return pet["hygiene"]
+
+
+def update_hygiene(pet, commits_behind):
+    """Lower hygiene as the number of commits behind origin increases."""
+    check_pet(pet, "hygiene")
+    check_count(commits_behind, "commits_behind")
+
+    before = pet["hygiene"]
+    pet["hygiene"] = clamp(
+        MAX_STAT - commits_behind * HYGIENE_LOSS_PER_COMMIT_BEHIND
+    )
+    return pet["hygiene"]