pawsona 0.1.0a1__tar.gz

pawsona-0.1.0a1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Pawsona contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pawsona-0.1.0a1/PKG-INFO

@@ -0,0 +1,113 @@
+Metadata-Version: 2.4
+Name: pawsona
+Version: 0.1.0a1
+Summary: Train personalities, not commands.
+Author: esmacimsit
+Maintainer: esmacimsit
+License-Expression: MIT
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: PyYAML>=6.0.2
+Dynamic: license-file
+
+# Pawsona
+
+Train personalities, not commands.
+
+Pawsona is a terminal-based pet personality and training simulator inspired by reinforcement learning, memory, adaptation, generalization, and overfitting.
+
+The first public version focuses on dogs. The behavior model is intentionally simple: it is a small scoring engine for playable training loops, not a biologically realistic simulator.
+
+## Current Status
+
+This repository is in the early CLI phase. Pawsona can load built-in pet profiles, inspect their model state, create new YAML profiles, and generate the first simple behavior-model actions.
+
+## Try It
+
+After release, the main install command will be:
+
+```bash
+pip install pawsona
+```
+
+Primary CLI:
+
+```bash
+pawsona --help
+```
+
+Short alias:
+
+```bash
+paw --help
+```
+
+If `paw` conflicts with another command on your machine, use `pawsona`.
+
+## Environment
+
+Create and activate the conda environment:
+
+```bash
+conda create -n paw python=3.11 pip
+conda activate paw
+```
+
+Install the project components from `requirements.txt`:
+
+```bash
+python -m pip install -r requirements.txt
+pawsona --help
+```
+
+## Inspect A Pet
+
+```bash
+pawsona inspect hermes
+pawsona inspect hera
+```
+
+## Create A Pet
+
+```bash
+pawsona create
+```
+
+Trait questions use a `1` to `5` scale and are normalized into `0.0` to `1.0` YAML values.
+
+## Generate An Action
+
+```bash
+pawsona act hermes
+pawsona act hera
+```
+
+## Train In The Terminal
+
+```bash
+pawsona play hermes
+pawsona play hera
+```
+
+Training sessions run for 10 rounds by default. Feedback options are `reward`, `praise`, `ignore`, and `correct`.
+
+Training updates are session-only until persistence lands in the next milestone.
+
+## Project Shape
+
+```text
+pawsona/
+  cli.py
+  behavior.py
+  pet.py
+  simple_yaml.py
+  training.py
+pets/
+  hermes.yaml
+  hera.yaml
+  template.yaml
+  community/
+saves/
+docs/
+```

pawsona-0.1.0a1/README.md

@@ -0,0 +1,100 @@
+# Pawsona
+
+Train personalities, not commands.
+
+Pawsona is a terminal-based pet personality and training simulator inspired by reinforcement learning, memory, adaptation, generalization, and overfitting.
+
+The first public version focuses on dogs. The behavior model is intentionally simple: it is a small scoring engine for playable training loops, not a biologically realistic simulator.
+
+## Current Status
+
+This repository is in the early CLI phase. Pawsona can load built-in pet profiles, inspect their model state, create new YAML profiles, and generate the first simple behavior-model actions.
+
+## Try It
+
+After release, the main install command will be:
+
+```bash
+pip install pawsona
+```
+
+Primary CLI:
+
+```bash
+pawsona --help
+```
+
+Short alias:
+
+```bash
+paw --help
+```
+
+If `paw` conflicts with another command on your machine, use `pawsona`.
+
+## Environment
+
+Create and activate the conda environment:
+
+```bash
+conda create -n paw python=3.11 pip
+conda activate paw
+```
+
+Install the project components from `requirements.txt`:
+
+```bash
+python -m pip install -r requirements.txt
+pawsona --help
+```
+
+## Inspect A Pet
+
+```bash
+pawsona inspect hermes
+pawsona inspect hera
+```
+
+## Create A Pet
+
+```bash
+pawsona create
+```
+
+Trait questions use a `1` to `5` scale and are normalized into `0.0` to `1.0` YAML values.
+
+## Generate An Action
+
+```bash
+pawsona act hermes
+pawsona act hera
+```
+
+## Train In The Terminal
+
+```bash
+pawsona play hermes
+pawsona play hera
+```
+
+Training sessions run for 10 rounds by default. Feedback options are `reward`, `praise`, `ignore`, and `correct`.
+
+Training updates are session-only until persistence lands in the next milestone.
+
+## Project Shape
+
+```text
+pawsona/
+  cli.py
+  behavior.py
+  pet.py
+  simple_yaml.py
+  training.py
+pets/
+  hermes.yaml
+  hera.yaml
+  template.yaml
+  community/
+saves/
+docs/
+```

pawsona-0.1.0a1/pawsona/__init__.py

@@ -0,0 +1,3 @@
+"""Pawsona package."""
+
+__version__ = "0.1.0a1"

pawsona-0.1.0a1/pawsona/__main__.py

@@ -0,0 +1,3 @@
+from pawsona.cli import main
+
+raise SystemExit(main())

pawsona-0.1.0a1/pawsona/behavior.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from pawsona.pet import Pet
+
+
+@dataclass(frozen=True)
+class Scenario:
+    name: str
+    environment: str
+    cue: str
+    distraction: str
+    goal: str
+    target_action: str
+    target_skill: str
+
+
+DEFAULT_SCENARIO = Scenario(
+    name="owner_arrives_home",
+    environment="home",
+    cue="greeting",
+    distraction="door_noise",
+    goal="stay calm when the owner arrives",
+    target_action="observe_calmly",
+    target_skill="settle",
+)
+
+
+def choose_action(pet: Pet, scenario: Scenario = DEFAULT_SCENARIO) -> tuple[str, dict[str, float]]:
+    scores = score_actions(pet, scenario)
+    action = max(scores, key=scores.get)
+    return action, scores
+
+
+def score_actions(pet: Pet, scenario: Scenario = DEFAULT_SCENARIO) -> dict[str, float]:
+    traits = pet.traits
+    skills = pet.skills
+    memory = pet.memory
+
+    home_bias = memory.get(scenario.environment, 0.0)
+    distraction_bias = memory.get(scenario.distraction, 0.0)
+
+    scores = {
+        "observe_calmly": (
+            traits["self_control"] * 0.35
+            + skills["settle"] * 0.30
+            + traits["confidence"] * 0.15
+            + home_bias * 0.10
+            - traits["impulsivity"] * 0.20
+        ),
+        "jump_excitedly": (
+            traits["energy"] * 0.25
+            + traits["affection_seeking"] * 0.25
+            + traits["attachment"] * 0.20
+            + traits["impulsivity"] * 0.20
+            - skills["settle"] * 0.15
+        ),
+        "bark_at_noise": (
+            traits["vigilance"] * 0.35
+            + traits["sensitivity"] * 0.20
+            + max(distraction_bias, 0.0) * 0.15
+            - traits["confidence"] * 0.10
+        ),
+        "bring_toy": (
+            skills["fetch"] * 0.35
+            + traits["play_drive"] * 0.25
+            + traits["sociability"] * 0.10
+            + memory.get("toy", 0.0) * 0.10
+        ),
+        "return_to_owner": (
+            skills["recall"] * 0.35
+            + skills["focus"] * 0.20
+            + traits["trainability"] * 0.25
+            - traits["curiosity"] * 0.10
+        ),
+    }
+    return {action: round(score, 3) for action, score in scores.items()}

pawsona-0.1.0a1/pawsona/builtin_pets/hera.yaml

@@ -0,0 +1,39 @@
+name: Hera
+species: dog
+breed: pug
+age: 7
+sex: female
+neutered: true
+
+traits:
+  energy: 0.9
+  confidence: 0.25
+  sociability: 0.85
+  attachment: 0.95
+  affection_seeking: 1.0
+  curiosity: 0.5
+  impulsivity: 0.9
+  self_control: 0.15
+  sensitivity: 0.8
+  trainability: 0.55
+  vigilance: 0.55
+  food_drive: 0.95
+  play_drive: 0.75
+
+skills:
+  recall: 0.25
+  focus: 0.25
+  settle: 0.2
+  fetch: 0.2
+
+memory:
+  home: 0.45
+  door_noise: 0.2
+  toy: 0.65
+  owner_arrives_home: 0.7
+  outside: 0.85
+  food: 0.95
+  sweets: 0.8
+  separation: -0.7
+  running: 0.8
+  pooping_outside: -0.2

pawsona-0.1.0a1/pawsona/builtin_pets/hermes.yaml

@@ -0,0 +1,38 @@
+name: Hermes
+species: dog
+breed: pug
+age: 9
+sex: male
+neutered: false
+
+traits:
+  energy: 0.25
+  confidence: 0.75
+  sociability: 0.35
+  attachment: 0.8
+  affection_seeking: 0.2
+  curiosity: 0.7
+  impulsivity: 0.2
+  self_control: 0.85
+  sensitivity: 0.9
+  trainability: 0.55
+  vigilance: 0.85
+  food_drive: 0.8
+  play_drive: 0.15
+
+skills:
+  recall: 0.45
+  focus: 0.6
+  settle: 0.75
+  fetch: 0.2
+
+memory:
+  home: 0.6
+  door_noise: 0.1
+  toy: 0.2
+  owner_arrives_home: 0.7
+  outside: 0.8
+  meat: 0.9
+  sweets: -0.5
+  human_distress: 0.8
+  clean_bedding: 0.7

pawsona-0.1.0a1/pawsona/cli.py

@@ -0,0 +1,271 @@
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+from typing import Callable
+
+from pawsona.behavior import DEFAULT_SCENARIO, choose_action
+from pawsona.pet import SKILL_KEYS, TRAIT_KEYS, PetLoadError, load_pet, write_pet_profile
+from pawsona.training import normalize_feedback, scenario_for_round, train_once
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="pawsona",
+        description="Train personalities, not commands.",
+    )
+    parser.add_argument(
+        "--pets-dir",
+        default="pets",
+        help="Directory containing pet YAML definitions.",
+    )
+
+    subparsers = parser.add_subparsers(dest="command")
+
+    inspect_parser = subparsers.add_parser(
+        "inspect",
+        help="Load and display a pet definition.",
+    )
+    inspect_parser.add_argument("pet", help="Pet name, for example: hermes")
+
+    create_parser = subparsers.add_parser(
+        "create",
+        help="Create a pet YAML profile through a short questionnaire.",
+    )
+    create_parser.add_argument(
+        "--force",
+        action="store_true",
+        help="Overwrite an existing pet YAML file.",
+    )
+
+    act_parser = subparsers.add_parser(
+        "act",
+        help="Generate an action from a pet profile.",
+    )
+    act_parser.add_argument("pet", help="Pet name, for example: hermes")
+
+    play_parser = subparsers.add_parser(
+        "play",
+        help="Run an interactive training session.",
+    )
+    play_parser.add_argument("pet", help="Pet name, for example: hermes")
+    play_parser.add_argument(
+        "--rounds",
+        type=int,
+        default=10,
+        help="Number of training rounds to run.",
+    )
+
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+
+    if args.command == "inspect":
+        return inspect_pet(args.pet, Path(args.pets_dir))
+    if args.command == "create":
+        return create_pet(Path(args.pets_dir), force=args.force)
+    if args.command == "act":
+        return act_pet(args.pet, Path(args.pets_dir))
+    if args.command == "play":
+        return play_pet(args.pet, Path(args.pets_dir), rounds=args.rounds)
+
+    parser.print_help()
+    return 0
+
+
+def inspect_pet(name: str, pets_dir: Path) -> int:
+    try:
+        pet = load_pet(name, pets_dir)
+    except PetLoadError as error:
+        print(f"error: {error}")
+        return 1
+
+    print(f"Name: {pet.name}")
+    print(f"Species: {pet.species}")
+    print(f"Breed: {pet.breed}")
+    print(f"Age: {pet.age}")
+    print(f"Sex: {pet.sex}")
+    print(f"Neutered: {str(pet.neutered).lower()}")
+    print("Traits:")
+    for trait, value in sorted(pet.traits.items()):
+        print(f"  {trait}: {value}")
+    print("Skills:")
+    for skill, value in sorted(pet.skills.items()):
+        print(f"  {skill}: {value}")
+    print("Memory:")
+    for memory, value in sorted(pet.memory.items()):
+        print(f"  {memory}: {value}")
+    return 0
+
+
+def create_pet(pets_dir: Path, force: bool = False) -> int:
+    print("Create a Pawsona dog profile")
+    name = _ask_text("Name")
+    slug = _slugify(name)
+    path = pets_dir / f"{slug}.yaml"
+    if path.exists() and not force:
+        print(f"error: {path} already exists. Re-run with --force to overwrite.")
+        return 1
+
+    profile = {
+        "name": name,
+        "species": "dog",
+        "breed": _ask_text("Breed"),
+        "age": _ask_int("Age", minimum=0),
+        "sex": _ask_choice("Sex", {"female", "male", "unknown"}),
+        "neutered": _ask_bool("Neutered"),
+        "traits": {
+            trait: _normalize_scale(_ask_int(_trait_prompt(trait), minimum=1, maximum=5))
+            for trait in TRAIT_KEYS
+        },
+        "skills": {skill: 0.0 for skill in SKILL_KEYS},
+        "memory": {},
+    }
+
+    write_pet_profile(path, profile)
+    print(f"created: {path}")
+    return 0
+
+
+def act_pet(name: str, pets_dir: Path) -> int:
+    try:
+        pet = load_pet(name, pets_dir)
+    except PetLoadError as error:
+        print(f"error: {error}")
+        return 1
+
+    action, scores = choose_action(pet)
+    print(f"Scenario: {DEFAULT_SCENARIO.name}")
+    print(f"{pet.name} action: {action}")
+    print("Scores:")
+    for score_name, score in sorted(scores.items(), key=lambda item: item[1], reverse=True):
+        print(f"  {score_name}: {score}")
+    return 0
+
+
+def play_pet(name: str, pets_dir: Path, rounds: int) -> int:
+    if rounds < 1:
+        print("error: --rounds must be 1 or greater")
+        return 1
+
+    try:
+        pet = load_pet(name, pets_dir)
+    except PetLoadError as error:
+        print(f"error: {error}")
+        return 1
+
+    print(f"Training {pet.name} for {rounds} rounds")
+    print("Feedback: 1 reward, 2 praise, 3 ignore, 4 correct, q quit")
+
+    completed_rounds = 0
+    for round_index in range(rounds):
+        scenario = scenario_for_round(round_index)
+        action, scores = choose_action(pet, scenario)
+
+        print("")
+        print(f"Round {round_index + 1}/{rounds}")
+        print(f"Scenario: {scenario.name}")
+        print(f"Environment: {scenario.environment}")
+        print(f"Goal: {scenario.goal}")
+        print(f"Distraction: {scenario.distraction}")
+        print(f"{pet.name} action: {action}")
+        print(f"Top score: {scores[action]}")
+
+        feedback = _ask_feedback()
+        if feedback is None:
+            break
+
+        pet, updates = train_once(pet, scenario, feedback)
+        completed_rounds += 1
+        print("Updates:")
+        for key, delta in updates.items():
+            print(f"  {key} {delta:+.3f}")
+
+    print("")
+    print(f"Completed rounds: {completed_rounds}/{rounds}")
+    return 0
+
+
+def _ask_text(prompt: str, input_fn: Callable[[str], str] = input) -> str:
+    while True:
+        value = input_fn(f"{prompt}: ").strip()
+        if value:
+            return value
+        print("Please enter a value.")
+
+
+def _ask_int(
+    prompt: str,
+    minimum: int,
+    maximum: int | None = None,
+    input_fn: Callable[[str], str] = input,
+) -> int:
+    while True:
+        raw_value = input_fn(f"{prompt}: ").strip()
+        try:
+            value = int(raw_value)
+        except ValueError:
+            print("Please enter a whole number.")
+            continue
+        if value < minimum:
+            print(f"Please enter {minimum} or greater.")
+            continue
+        if maximum is not None and value > maximum:
+            print(f"Please enter {maximum} or lower.")
+            continue
+        return value
+
+
+def _ask_bool(prompt: str, input_fn: Callable[[str], str] = input) -> bool:
+    while True:
+        value = input_fn(f"{prompt} [y/n]: ").strip().lower()
+        if value in {"y", "yes"}:
+            return True
+        if value in {"n", "no"}:
+            return False
+        print("Please answer y or n.")
+
+
+def _ask_choice(
+    prompt: str,
+    choices: set[str],
+    input_fn: Callable[[str], str] = input,
+) -> str:
+    options = "/".join(sorted(choices))
+    while True:
+        value = input_fn(f"{prompt} [{options}]: ").strip().lower()
+        if value in choices:
+            return value
+        print(f"Please choose one of: {options}.")
+
+
+def _ask_feedback(input_fn: Callable[[str], str] = input) -> str | None:
+    while True:
+        try:
+            value = input_fn("Your feedback: ").strip().lower()
+        except EOFError:
+            print("")
+            return None
+        if value in {"q", "quit", "exit"}:
+            return None
+        feedback = normalize_feedback(value)
+        if feedback is not None:
+            return feedback
+        print("Please choose 1, 2, 3, 4, or q.")
+
+
+def _normalize_scale(value: int) -> float:
+    return round((value - 1) / 4, 2)
+
+
+def _slugify(value: str) -> str:
+    slug = "".join(character.lower() if character.isalnum() else "_" for character in value)
+    return "_".join(part for part in slug.split("_") if part)
+
+
+def _trait_prompt(trait: str) -> str:
+    label = trait.replace("_", " ")
+    return f"{label} (1-5)"

pawsona-0.1.0a1/pawsona/pet.py

@@ -0,0 +1,170 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from importlib import resources
+from pathlib import Path
+from typing import Any
+
+from pawsona.simple_yaml import load_yaml_mapping, load_yaml_text, write_yaml_mapping
+
+
+class PetLoadError(Exception):
+    """Raised when a pet definition cannot be loaded."""
+
+
+TRAIT_KEYS = (
+    "energy",
+    "confidence",
+    "sociability",
+    "attachment",
+    "affection_seeking",
+    "curiosity",
+    "impulsivity",
+    "self_control",
+    "sensitivity",
+    "trainability",
+    "vigilance",
+    "food_drive",
+    "play_drive",
+)
+
+SKILL_KEYS = (
+    "recall",
+    "focus",
+    "settle",
+    "fetch",
+)
+
+
+@dataclass(frozen=True)
+class Pet:
+    name: str
+    species: str
+    breed: str
+    age: int
+    sex: str
+    neutered: bool
+    traits: dict[str, float]
+    skills: dict[str, float]
+    memory: dict[str, float]
+
+
+def load_pet(name: str, pets_dir: Path) -> Pet:
+    path = _find_pet_file(name, pets_dir)
+    if path is not None:
+        data = _read_yaml(path)
+        return _parse_pet(data, path)
+
+    data = _read_builtin_pet(name)
+    if data is not None:
+        return _parse_pet(data, f"built-in pet '{name}'")
+
+    raise PetLoadError(f"could not find pet '{name}' in {pets_dir} or built-in pets")
+
+
+def _find_pet_file(name: str, pets_dir: Path) -> Path | None:
+    candidates = [
+        pets_dir / f"{name}.yaml",
+        pets_dir / "community" / f"{name}.yaml",
+    ]
+    for candidate in candidates:
+        if candidate.exists():
+            return candidate
+    return None
+
+
+def _read_builtin_pet(name: str) -> dict[str, Any] | None:
+    resource = resources.files("pawsona").joinpath("builtin_pets", f"{name}.yaml")
+    if not resource.is_file():
+        return None
+    try:
+        return load_yaml_text(resource.read_text(encoding="utf-8"), source=str(resource))
+    except ValueError as error:
+        raise PetLoadError(str(error)) from error
+
+
+def _read_yaml(path: Path) -> dict[str, Any]:
+    try:
+        return load_yaml_mapping(path)
+    except ValueError as error:
+        raise PetLoadError(str(error)) from error
+
+
+def write_pet_profile(path: Path, profile: dict[str, Any]) -> None:
+    write_yaml_mapping(path, profile)
+
+
+def _parse_pet(data: dict[str, Any], path: Path | str) -> Pet:
+    try:
+        name = _require_string(data, "name")
+        species = _require_string(data, "species")
+        breed = _require_string(data, "breed")
+        age = _require_int(data, "age")
+        sex = _require_string(data, "sex")
+        neutered = _require_bool(data, "neutered")
+        traits = _require_number_map(data, "traits", required_keys=TRAIT_KEYS)
+        skills = _require_number_map(data, "skills", required_keys=SKILL_KEYS)
+        memory = _require_number_map(data, "memory")
+    except PetLoadError as error:
+        raise PetLoadError(f"{path}: {error}") from error
+
+    return Pet(
+        name=name,
+        species=species,
+        breed=breed,
+        age=age,
+        sex=sex,
+        neutered=neutered,
+        traits=traits,
+        skills=skills,
+        memory=memory,
+    )
+
+
+def _require_string(data: dict[str, Any], key: str) -> str:
+    value = data.get(key)
+    if not isinstance(value, str) or not value.strip():
+        raise PetLoadError(f"'{key}' must be a non-empty string")
+    return value
+
+
+def _require_int(data: dict[str, Any], key: str) -> int:
+    value = data.get(key)
+    if not isinstance(value, int) or isinstance(value, bool):
+        raise PetLoadError(f"'{key}' must be an integer")
+    if value < 0:
+        raise PetLoadError(f"'{key}' must be zero or greater")
+    return value
+
+
+def _require_bool(data: dict[str, Any], key: str) -> bool:
+    value = data.get(key)
+    if not isinstance(value, bool):
+        raise PetLoadError(f"'{key}' must be true or false")
+    return value
+
+
+def _require_number_map(
+    data: dict[str, Any],
+    key: str,
+    required_keys: tuple[str, ...] = (),
+) -> dict[str, float]:
+    value = data.get(key)
+    if not isinstance(value, dict):
+        raise PetLoadError(f"'{key}' must be a mapping")
+
+    missing = [required_key for required_key in required_keys if required_key not in value]
+    if missing:
+        raise PetLoadError(f"'{key}' is missing: {', '.join(missing)}")
+
+    result: dict[str, float] = {}
+    for item_key, item_value in value.items():
+        if not isinstance(item_key, str) or not item_key.strip():
+            raise PetLoadError(f"'{key}' keys must be non-empty strings")
+        if not isinstance(item_value, int | float) or isinstance(item_value, bool):
+            raise PetLoadError(f"'{key}.{item_key}' must be a number")
+        numeric_value = float(item_value)
+        if numeric_value < -1.0 or numeric_value > 1.0:
+            raise PetLoadError(f"'{key}.{item_key}' must be between -1.0 and 1.0")
+        result[item_key] = numeric_value
+    return result

pawsona-0.1.0a1/pawsona/simple_yaml.py

@@ -0,0 +1,108 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+
+def load_yaml_mapping(path: Path) -> dict[str, Any]:
+    return load_yaml_text(path.read_text(encoding="utf-8"), source=str(path))
+
+
+def load_yaml_text(text: str, source: str = "<yaml>") -> dict[str, Any]:
+    try:
+        import yaml
+    except ImportError:
+        return _load_simple_yaml_text(text, source)
+
+    data = yaml.safe_load(text)
+
+    if not isinstance(data, dict):
+        raise ValueError(f"{source} must contain a YAML mapping")
+    return data
+
+
+def write_yaml_mapping(path: Path, data: dict[str, Any]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open("w", encoding="utf-8") as file:
+        file.write(_dump_simple_yaml_mapping(data))
+
+
+def _load_simple_yaml_mapping(path: Path) -> dict[str, Any]:
+    return _load_simple_yaml_text(path.read_text(encoding="utf-8"), str(path))
+
+
+def _load_simple_yaml_text(text: str, source: str) -> dict[str, Any]:
+    root: dict[str, Any] = {}
+    current_map: dict[str, Any] | None = None
+
+    for line_number, raw_line in enumerate(text.splitlines(), 1):
+        line = raw_line.split("#", 1)[0].rstrip()
+        if not line:
+            continue
+
+        indent = len(line) - len(line.lstrip(" "))
+        stripped = line.strip()
+        if ":" not in stripped:
+            raise ValueError(f"{source}:{line_number}: expected 'key: value'")
+
+        key, raw_value = stripped.split(":", 1)
+        key = key.strip()
+        raw_value = raw_value.strip()
+        if not key:
+            raise ValueError(f"{source}:{line_number}: missing key")
+
+        if indent == 0:
+            if raw_value == "":
+                current_map = {}
+                root[key] = current_map
+            else:
+                current_map = None
+                root[key] = _parse_scalar(raw_value)
+        elif indent == 2:
+            if current_map is None:
+                raise ValueError(f"{source}:{line_number}: nested value without a parent")
+            current_map[key] = _parse_scalar(raw_value)
+        else:
+            raise ValueError(f"{source}:{line_number}: only two-space nesting is supported")
+
+    return root
+
+
+def _parse_scalar(value: str) -> Any:
+    if value == "{}":
+        return {}
+    if value in {"true", "True"}:
+        return True
+    if value in {"false", "False"}:
+        return False
+    if value in {"null", "None", "~"}:
+        return None
+    try:
+        if "." in value:
+            return float(value)
+        return int(value)
+    except ValueError:
+        return value.strip("\"'")
+
+
+def _dump_simple_yaml_mapping(data: dict[str, Any]) -> str:
+    lines: list[str] = []
+    for key, value in data.items():
+        if isinstance(value, dict):
+            if value:
+                lines.append(f"{key}:")
+                for nested_key, nested_value in value.items():
+                    lines.append(f"  {nested_key}: {_format_scalar(nested_value)}")
+            else:
+                lines.append(f"{key}: {{}}")
+        else:
+            lines.append(f"{key}: {_format_scalar(value)}")
+        if key in {"neutered", "traits", "skills"}:
+            lines.append("")
+    return "\n".join(lines).rstrip() + "\n"
+
+
+def _format_scalar(value: Any) -> str:
+    if isinstance(value, bool):
+        return "true" if value else "false"
+    return str(value)

pawsona-0.1.0a1/pawsona/training.py

@@ -0,0 +1,145 @@
+from __future__ import annotations
+
+from dataclasses import replace
+
+from pawsona.behavior import Scenario, choose_action
+from pawsona.pet import Pet
+
+
+SCENARIOS = (
+    Scenario(
+        name="owner_arrives_home",
+        environment="home",
+        cue="greeting",
+        distraction="door_noise",
+        goal="stay calm when the owner arrives",
+        target_action="observe_calmly",
+        target_skill="settle",
+    ),
+    Scenario(
+        name="recall_from_yard",
+        environment="outside",
+        cue="recall",
+        distraction="squirrel",
+        goal="return when called",
+        target_action="return_to_owner",
+        target_skill="recall",
+    ),
+    Scenario(
+        name="fetch_at_park",
+        environment="park",
+        cue="fetch",
+        distraction="squirrel",
+        goal="bring the toy back",
+        target_action="bring_toy",
+        target_skill="fetch",
+    ),
+    Scenario(
+        name="focus_near_food",
+        environment="kitchen",
+        cue="focus",
+        distraction="meat",
+        goal="keep attention on the owner",
+        target_action="return_to_owner",
+        target_skill="focus",
+    ),
+    Scenario(
+        name="settle_during_noise",
+        environment="home",
+        cue="settle",
+        distraction="door_noise",
+        goal="settle through a noise",
+        target_action="observe_calmly",
+        target_skill="settle",
+    ),
+)
+
+FEEDBACK_LABELS = {
+    "1": "reward",
+    "2": "praise",
+    "3": "ignore",
+    "4": "correct",
+    "reward": "reward",
+    "praise": "praise",
+    "ignore": "ignore",
+    "correct": "correct",
+}
+
+ACTION_SKILLS = {
+    "observe_calmly": "settle",
+    "jump_excitedly": "settle",
+    "bark_at_noise": "focus",
+    "bring_toy": "fetch",
+    "return_to_owner": "recall",
+}
+
+
+def scenario_for_round(round_index: int) -> Scenario:
+    return SCENARIOS[round_index % len(SCENARIOS)]
+
+
+def normalize_feedback(value: str) -> str | None:
+    return FEEDBACK_LABELS.get(value.strip().lower())
+
+
+def train_once(pet: Pet, scenario: Scenario, feedback: str) -> tuple[Pet, dict[str, float]]:
+    action, _scores = choose_action(pet, scenario)
+    skill_updates = _skill_updates(action, scenario, feedback)
+    memory_updates = _memory_updates(action, scenario, feedback)
+
+    skills = dict(pet.skills)
+    memory = dict(pet.memory)
+    applied: dict[str, float] = {}
+
+    for skill, delta in skill_updates.items():
+        old_value = skills.get(skill, 0.0)
+        new_value = _clamp(old_value + delta)
+        skills[skill] = new_value
+        applied[f"{skill}_skill"] = round(new_value - old_value, 3)
+
+    for key, delta in memory_updates.items():
+        old_value = memory.get(key, 0.0)
+        new_value = _clamp(old_value + delta, minimum=-1.0)
+        memory[key] = new_value
+        applied[f"{key}_memory"] = round(new_value - old_value, 3)
+
+    return replace(pet, skills=skills, memory=memory), applied
+
+
+def _skill_updates(action: str, scenario: Scenario, feedback: str) -> dict[str, float]:
+    action_skill = ACTION_SKILLS.get(action, scenario.target_skill)
+
+    if feedback == "reward":
+        return {action_skill: 0.05}
+    if feedback == "praise":
+        return {action_skill: 0.03}
+    if feedback == "correct":
+        updates = {scenario.target_skill: 0.03}
+        if action != scenario.target_action:
+            updates[action_skill] = updates.get(action_skill, 0.0) - 0.02
+        return updates
+    return {scenario.target_skill: -0.005}
+
+
+def _memory_updates(action: str, scenario: Scenario, feedback: str) -> dict[str, float]:
+    if feedback == "reward":
+        return {
+            scenario.name: 0.04,
+            scenario.environment: 0.02,
+            scenario.distraction: 0.01 if action == scenario.target_action else -0.02,
+        }
+    if feedback == "praise":
+        return {
+            scenario.name: 0.025,
+            scenario.environment: 0.015,
+        }
+    if feedback == "correct":
+        return {
+            scenario.name: -0.02,
+            scenario.distraction: -0.03,
+        }
+    return {scenario.name: -0.005}
+
+
+def _clamp(value: float, minimum: float = 0.0, maximum: float = 1.0) -> float:
+    return round(max(minimum, min(maximum, value)), 3)

pawsona-0.1.0a1/pawsona.egg-info/PKG-INFO

@@ -0,0 +1,113 @@
+Metadata-Version: 2.4
+Name: pawsona
+Version: 0.1.0a1
+Summary: Train personalities, not commands.
+Author: esmacimsit
+Maintainer: esmacimsit
+License-Expression: MIT
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: PyYAML>=6.0.2
+Dynamic: license-file
+
+# Pawsona
+
+Train personalities, not commands.
+
+Pawsona is a terminal-based pet personality and training simulator inspired by reinforcement learning, memory, adaptation, generalization, and overfitting.
+
+The first public version focuses on dogs. The behavior model is intentionally simple: it is a small scoring engine for playable training loops, not a biologically realistic simulator.
+
+## Current Status
+
+This repository is in the early CLI phase. Pawsona can load built-in pet profiles, inspect their model state, create new YAML profiles, and generate the first simple behavior-model actions.
+
+## Try It
+
+After release, the main install command will be:
+
+```bash
+pip install pawsona
+```
+
+Primary CLI:
+
+```bash
+pawsona --help
+```
+
+Short alias:
+
+```bash
+paw --help
+```
+
+If `paw` conflicts with another command on your machine, use `pawsona`.
+
+## Environment
+
+Create and activate the conda environment:
+
+```bash
+conda create -n paw python=3.11 pip
+conda activate paw
+```
+
+Install the project components from `requirements.txt`:
+
+```bash
+python -m pip install -r requirements.txt
+pawsona --help
+```
+
+## Inspect A Pet
+
+```bash
+pawsona inspect hermes
+pawsona inspect hera
+```
+
+## Create A Pet
+
+```bash
+pawsona create
+```
+
+Trait questions use a `1` to `5` scale and are normalized into `0.0` to `1.0` YAML values.
+
+## Generate An Action
+
+```bash
+pawsona act hermes
+pawsona act hera
+```
+
+## Train In The Terminal
+
+```bash
+pawsona play hermes
+pawsona play hera
+```
+
+Training sessions run for 10 rounds by default. Feedback options are `reward`, `praise`, `ignore`, and `correct`.
+
+Training updates are session-only until persistence lands in the next milestone.
+
+## Project Shape
+
+```text
+pawsona/
+  cli.py
+  behavior.py
+  pet.py
+  simple_yaml.py
+  training.py
+pets/
+  hermes.yaml
+  hera.yaml
+  template.yaml
+  community/
+saves/
+docs/
+```

pawsona-0.1.0a1/pawsona.egg-info/SOURCES.txt

@@ -0,0 +1,18 @@
+LICENSE
+README.md
+pyproject.toml
+pawsona/__init__.py
+pawsona/__main__.py
+pawsona/behavior.py
+pawsona/cli.py
+pawsona/pet.py
+pawsona/simple_yaml.py
+pawsona/training.py
+pawsona.egg-info/PKG-INFO
+pawsona.egg-info/SOURCES.txt
+pawsona.egg-info/dependency_links.txt
+pawsona.egg-info/entry_points.txt
+pawsona.egg-info/requires.txt
+pawsona.egg-info/top_level.txt
+pawsona/builtin_pets/hera.yaml
+pawsona/builtin_pets/hermes.yaml

pawsona-0.1.0a1/pawsona.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pawsona-0.1.0a1/pawsona.egg-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+paw = pawsona.cli:main
+pawsona = pawsona.cli:main

pawsona-0.1.0a1/pawsona.egg-info/requires.txt

@@ -0,0 +1 @@
+PyYAML>=6.0.2

pawsona-0.1.0a1/pawsona.egg-info/top_level.txt

@@ -0,0 +1 @@
+pawsona

pawsona-0.1.0a1/pyproject.toml

@@ -0,0 +1,30 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pawsona"
+version = "0.1.0a1"
+description = "Train personalities, not commands."
+readme = "README.md"
+requires-python = ">=3.11"
+license = "MIT"
+authors = [
+  { name = "esmacimsit" },
+]
+maintainers = [
+  { name = "esmacimsit" },
+]
+dependencies = [
+  "PyYAML>=6.0.2",
+]
+
+[project.scripts]
+pawsona = "pawsona.cli:main"
+paw = "pawsona.cli:main"
+
+[tool.setuptools.packages.find]
+include = ["pawsona*"]
+
+[tool.setuptools.package-data]
+pawsona = ["builtin_pets/*.yaml"]

pawsona-0.1.0a1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+