ptg-editor 0.1.0__tar.gz

ptg_editor-0.1.0/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: ptg-editor
+Version: 0.1.0
+Summary: Web-based editor for PTG card game sets
+Author: Daniel Pérez Rodríguez
+Requires-Python: >=3.10
+Requires-Dist: ptg>=0.1.19
+Requires-Dist: flask>=3.0
+Requires-Dist: pyyaml>=6.0

ptg_editor-0.1.0/pyproject.toml

@@ -0,0 +1,29 @@
+[project]
+name = "ptg-editor"
+version = "0.1.0"
+description = "Web-based editor for PTG card game sets"
+requires-python = ">=3.10"
+authors = [
+    {name = "Daniel Pérez Rodríguez"}
+]
+dependencies = [
+    "ptg>=0.1.19",
+    "flask>=3.0",
+    "pyyaml>=6.0",
+]
+
+[project.scripts]
+ptg-editor = "ptg_editor.main:main"
+
+[build-system]
+requires = ["setuptools>=68.0"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+ptg_editor = [
+    "templates/**/*",
+    "static/**/*",
+]

ptg_editor-0.1.0/setup.cfg

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

ptg_editor-0.1.0/src/ptg_editor/app.py

@@ -0,0 +1,88 @@
+"""Flask application factory and entry point."""
+
+from __future__ import annotations
+
+import re
+import sys
+from pathlib import Path
+
+from flask import Flask
+from markupsafe import Markup
+
+from ptg_editor.config import load_config, get_base_dir
+
+MANA_LABEL_MAP = {
+    "F": "fire", "E": "earth", "W": "water", "A": "air", "Y": "any",
+    "fire": "fire", "earth": "earth", "water": "water", "air": "air", "any": "any",
+}
+
+
+def _mana_to_badges_html(mana) -> str:
+    """Convert mana dict or string like 'F2 A1' into HTML badge spans."""
+    if isinstance(mana, dict):
+        parts = []
+        for key, val in mana.items():
+            key_str = key.value if hasattr(key, 'value') else str(key)
+            if val and val > 0:
+                label = "Y" if key_str == "any" else key_str[0].upper()
+                parts.append(f"{label}{val}")
+    elif isinstance(mana, str) and mana.strip():
+        parts = mana.strip().split()
+    else:
+        return ""
+
+    badges = []
+    for part in parts:
+        m = re.match(r"^([A-Za-z])(\d+)$", part)
+        if not m:
+            continue
+        label, amount = m.group(1).upper(), m.group(2)
+        mana_key = MANA_LABEL_MAP.get(label, "any")
+        badges.append(
+            f'<span class="mana-badge mana-badge-{mana_key}">'
+            f'{label}{amount}'
+            f'</span>'
+        )
+    return " ".join(badges)
+
+
+def create_app(config: dict | None = None) -> Flask:
+    if config is None:
+        config = load_config()
+
+    app = Flask(__name__)
+    app.secret_key = "ptg-editor-session-key"
+    app.config["PTG_CONFIG"] = config
+    app.config["PTG_BASE_DIR"] = get_base_dir(config)
+    app.config["PTG_BASE_DIR"].mkdir(parents=True, exist_ok=True)
+
+    app.jinja_env.globals["hasattr"] = hasattr
+
+    @app.template_filter("mana_badges")
+    def mana_badges(mana) -> str:
+        return Markup(_mana_to_badges_html(mana))
+
+    from ptg_editor.routes.views import views_bp
+    from ptg_editor.routes.api import api_bp
+
+    app.register_blueprint(views_bp)
+    app.register_blueprint(api_bp, url_prefix="/api")
+
+    return app
+
+
+def main() -> None:
+    config = load_config()
+    app = create_app(config)
+    server = config.get("server", {})
+    host = server.get("host", "0.0.0.0")
+    port = server.get("port", 5000)
+    debug = config.get("editor", {}).get("debug", False)
+
+    print(f"PTG Editor server starting on http://{host}:{port}")
+    print(f"Sets directory: {app.config['PTG_BASE_DIR']}")
+    app.run(host=host, port=port, debug=debug)
+
+
+if __name__ == "__main__":
+    main()

ptg_editor-0.1.0/src/ptg_editor/config.py

@@ -0,0 +1,68 @@
+"""Application configuration loader."""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+
+DEFAULT_CONFIG: dict[str, Any] = {
+    "server": {
+        "host": "0.0.0.0",
+        "port": 5000,
+    },
+    "sets": {
+        "base_dir": "",
+    },
+    "editor": {
+        "debug": False,
+    },
+}
+
+
+def _find_config_path() -> Path | None:
+    env_path = os.environ.get("PTG_EDITOR_CONFIG")
+    if env_path:
+        p = Path(env_path)
+        if p.exists():
+            return p
+
+    cwd_path = Path.cwd() / "config.yaml"
+    if cwd_path.exists():
+        return cwd_path
+
+    home_path = Path.home() / ".config" / "ptg-editor" / "config.yaml"
+    if home_path.exists():
+        return home_path
+
+    return None
+
+
+def _deep_merge(base: dict, override: dict) -> dict:
+    result = dict(base)
+    for key, value in override.items():
+        if key in result and isinstance(result[key], dict) and isinstance(value, dict):
+            result[key] = _deep_merge(result[key], value)
+        else:
+            result[key] = value
+    return result
+
+
+def load_config() -> dict[str, Any]:
+    config = dict(DEFAULT_CONFIG)
+    path = _find_config_path()
+    if path:
+        with open(path, "r", encoding="utf-8") as f:
+            user_config = yaml.safe_load(f) or {}
+        config = _deep_merge(config, user_config)
+    return config
+
+
+def get_base_dir(config: dict[str, Any]) -> Path:
+    base = config.get("sets", {}).get("base_dir", "")
+    if base:
+        return Path(base).resolve()
+    return (Path.cwd() / "sets").resolve()

ptg_editor-0.1.0/src/ptg_editor/main.py

@@ -0,0 +1,8 @@
+"""Entry point for PTG Editor Flask server."""
+
+from __future__ import annotations
+
+from ptg_editor.app import main
+
+if __name__ == "__main__":
+    main()

ptg_editor-0.1.0/src/ptg_editor/routes/api.py

@@ -0,0 +1,395 @@
+"""JSON API routes."""
+
+from __future__ import annotations
+
+import os
+import tempfile
+from pathlib import Path
+
+from flask import Blueprint, request, jsonify, current_app, send_from_directory
+
+from ptg_editor.set_manager import SetManager
+from ptg_editor.services import (
+    card_to_yaml, validate_card_yaml, save_card_yaml, load_card_from_file,
+    yaml_to_form_data, list_effects,
+)
+
+api_bp = Blueprint("api", __name__)
+
+
+def _get_base_dir() -> Path:
+    return current_app.config["PTG_BASE_DIR"]
+
+
+def _get_set(set_id: str) -> SetManager:
+    base = _get_base_dir()
+    return SetManager.open_with_reload(str(base / set_id))
+
+
+# ─── Sets ────────────────────────────────────────────────────────────
+
+@api_bp.route("/sets", methods=["GET"])
+def list_sets():
+    base = _get_base_dir()
+    sets = []
+    if base.exists():
+        for entry in sorted(base.iterdir()):
+            if not entry.is_dir():
+                continue
+            manifest_path = entry / "manifest.yaml"
+            if not manifest_path.exists():
+                continue
+            try:
+                sm = SetManager.open(entry)
+                sets.append({
+                    "set_id": sm.manifest.get("id", entry.name),
+                    "name": sm.name,
+                    "author": sm.manifest.get("author", ""),
+                    "description": sm.manifest.get("description", ""),
+                    "version": sm.manifest.get("version", ""),
+                    "dir_name": entry.name,
+                    "card_count": sum(1 for _ in (entry / "catalog").glob("*.yaml")) +
+                                  sum(1 for _ in (entry / "catalog").glob("*.yml")),
+                })
+            except Exception:
+                pass
+    return jsonify(sets)
+
+
+@api_bp.route("/sets", methods=["POST"])
+def create_set():
+    data = request.get_json(silent=True) or {}
+    set_id = data.get("set_id", "").strip()
+    name = data.get("name", "").strip()
+    if not set_id or not name:
+        return jsonify({"error": "set_id and name are required"}), 400
+
+    base = _get_base_dir()
+    set_dir = base / set_id
+    if set_dir.exists():
+        return jsonify({"error": f"Set directory already exists: {set_dir}"}), 409
+
+    try:
+        SetManager.create(
+            directory=str(set_dir),
+            set_id=set_id,
+            name=name,
+            author=data.get("author", ""),
+            description=data.get("description", ""),
+        )
+        return jsonify({"success": True, "set_id": set_id})
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+
+@api_bp.route("/sets/<set_id>/reload", methods=["POST"])
+def reload_set(set_id: str):
+    try:
+        sm = _get_set(set_id)
+        return jsonify({
+            "success": True,
+            "name": sm.name,
+            "card_count": sm.card_count,
+            "deck_list": sm.deck_list,
+        })
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+
+# ─── Cards ────────────────────────────────────────────────────────────
+
+@api_bp.route("/sets/<set_id>/cards", methods=["GET"])
+def list_cards(set_id: str):
+    try:
+        sm = _get_set(set_id)
+        cards = []
+        for card in sm.catalog.values():
+            card_type = card.type.value if hasattr(card.type, 'value') else str(card.type)
+            mana_cost = _mana_display(card.mana)
+            cards.append({
+                "card_id": card.card_id,
+                "name": card.name,
+                "type": card_type,
+                "mana": mana_cost,
+                "attack": card.attack,
+                "defense": card.defense,
+            })
+        cards.sort(key=lambda c: c["name"].lower())
+        return jsonify(cards)
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+
+@api_bp.route("/sets/<set_id>/cards/<card_id>", methods=["GET"])
+def get_card(set_id: str, card_id: str):
+    try:
+        sm = _get_set(set_id)
+        filepath = sm.card_paths.get(card_id)
+        if not filepath:
+            return jsonify({"error": f"Card not found: {card_id}"}), 404
+        yaml_text = load_card_from_file(filepath)
+        data = yaml_to_form_data(yaml_text)
+        art = sm.get_art(card_id)
+        if art:
+            data["art_filename"] = art
+        return jsonify(data)
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+
+@api_bp.route("/sets/<set_id>/cards", methods=["POST"])
+def save_card(set_id: str):
+    data = request.get_json(silent=True) or {}
+    card_data = data.get("data") or data
+    old_card_id = data.get("old_card_id", "")
+
+    card_id = card_data.get("card_id", "").strip()
+    if not card_id:
+        return jsonify({"error": "card_id is required"}), 400
+
+    try:
+        sm = _get_set(set_id)
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+    try:
+        yaml_text = card_to_yaml(card_data)
+    except Exception as e:
+        return jsonify({"error": f"YAML generation failed: {e}"}), 400
+
+    target_path = str(sm.card_path_for(card_id))
+
+    if old_card_id and old_card_id != card_id:
+        old_path = sm.card_paths.get(old_card_id)
+        if old_path and Path(old_path).exists():
+            sm.rename_card_file(old_path, card_id)
+        sm.rename_card_in_decks(old_card_id, card_id)
+
+    if Path(target_path).exists():
+        existing_id = None
+        for cid, cpath in sm.card_paths.items():
+            if cpath == target_path and cid != card_id:
+                existing_id = cid
+                break
+        if existing_id and not data.get("overwrite", False):
+            return jsonify({
+                "error": f"Card ID '{existing_id}' already exists at this path.",
+                "conflict": True,
+                "existing_id": existing_id,
+            }), 409
+
+    save_card_yaml(yaml_text, target_path)
+    sm.reload()
+
+    return jsonify({"success": True, "card_id": card_id})
+
+
+@api_bp.route("/sets/<set_id>/cards/<card_id>", methods=["DELETE"])
+def delete_card(set_id: str, card_id: str):
+    try:
+        sm = _get_set(set_id)
+        filepath = sm.card_paths.get(card_id)
+        if filepath and Path(filepath).exists():
+            Path(filepath).unlink()
+            sm.reload()
+        return jsonify({"success": True})
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+
+# ─── Preview & Validate ──────────────────────────────────────────────
+
+@api_bp.route("/preview", methods=["POST"])
+def preview():
+    data = request.get_json(silent=True) or {}
+    try:
+        yaml_text = card_to_yaml(data)
+        return jsonify({"yaml": yaml_text})
+    except Exception as e:
+        return jsonify({"error": str(e)}), 400
+
+
+@api_bp.route("/validate", methods=["POST"])
+def validate():
+    data = request.get_json(silent=True) or {}
+    if "yaml" in data:
+        yaml_text = data["yaml"]
+    else:
+        try:
+            yaml_text = card_to_yaml(data)
+        except Exception as e:
+            return jsonify({"valid": False, "message": f"YAML generation failed: {e}"})
+
+    is_valid, message = validate_card_yaml(yaml_text)
+    return jsonify({"valid": is_valid, "message": message})
+
+
+@api_bp.route("/sets/<set_id>/validate-all", methods=["POST"])
+def validate_all(set_id: str):
+    try:
+        sm = _get_set(set_id)
+        results = sm.validate_all()
+        total = len(results)
+        ok = sum(1 for v in results.values() if v == "OK")
+        return jsonify({"results": results, "total": total, "ok": ok})
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+
+# ─── Decks ────────────────────────────────────────────────────────────
+
+@api_bp.route("/sets/<set_id>/decks", methods=["GET"])
+def list_decks(set_id: str):
+    try:
+        sm = _get_set(set_id)
+        decks = []
+        for name in sm.deck_list:
+            try:
+                spec = sm.load_deck_spec(name)
+                total = sum(spec.values())
+                decks.append({"name": name, "total_cards": total, "spec": spec})
+            except Exception:
+                decks.append({"name": name, "total_cards": 0, "spec": {}})
+        return jsonify(decks)
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+
+@api_bp.route("/sets/<set_id>/decks/<name>", methods=["GET"])
+def get_deck(set_id: str, name: str):
+    try:
+        sm = _get_set(set_id)
+        spec = sm.load_deck_spec(name)
+        return jsonify({"name": name, "spec": spec})
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+
+@api_bp.route("/sets/<set_id>/decks", methods=["POST"])
+def save_deck(set_id: str):
+    data = request.get_json(silent=True) or {}
+    name = data.get("name", "").strip()
+    spec = data.get("spec", {})
+    if not name:
+        return jsonify({"error": "Deck name is required"}), 400
+    if not spec:
+        return jsonify({"error": "Deck spec is empty"}), 400
+
+    try:
+        sm = _get_set(set_id)
+        sm.add_deck(name, spec)
+        return jsonify({"success": True, "name": name})
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+
+@api_bp.route("/sets/<set_id>/decks/<name>", methods=["DELETE"])
+def delete_deck(set_id: str, name: str):
+    try:
+        sm = _get_set(set_id)
+        sm.remove_deck(name)
+        return jsonify({"success": True})
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+
+# ─── Art ──────────────────────────────────────────────────────────────
+
+@api_bp.route("/sets/<set_id>/art/<card_id>", methods=["GET"])
+def get_art(set_id: str, card_id: str):
+    try:
+        base = _get_base_dir()
+        sm = SetManager.open(str(base / set_id))
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+    filename = sm.get_art(card_id)
+    if not filename:
+        return jsonify({"error": "No art for this card"}), 404
+
+    art_path = sm.art_dir / filename
+    if not art_path.exists():
+        return jsonify({"error": "Art file not found"}), 404
+
+    return send_from_directory(str(sm.art_dir), filename)
+
+
+@api_bp.route("/sets/<set_id>/art/<card_id>", methods=["POST"])
+def upload_art(set_id: str, card_id: str):
+    if "file" not in request.files:
+        return jsonify({"error": "No file provided"}), 400
+
+    file = request.files["file"]
+    if file.filename == "":
+        return jsonify({"error": "No file selected"}), 400
+
+    try:
+        base = _get_base_dir()
+        sm = SetManager.open(str(base / set_id))
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+    ext = Path(file.filename).suffix.lower()
+    if ext not in (".png", ".jpg", ".jpeg", ".gif", ".bmp", ".webp"):
+        return jsonify({"error": f"Unsupported image format: {ext}"}), 400
+
+    dest_filename = f"{card_id}{ext}"
+    dest_path = sm.art_dir / dest_filename
+    sm.art_dir.mkdir(exist_ok=True)
+    file.save(str(dest_path))
+
+    # Remove old art file if different extension
+    old_filename = sm.get_art(card_id)
+    if old_filename and old_filename != dest_filename:
+        old_path = sm.art_dir / old_filename
+        if old_path.exists():
+            old_path.unlink()
+
+    sm.set_art(card_id, dest_filename)
+    return jsonify({"success": True, "filename": dest_filename})
+
+
+@api_bp.route("/sets/<set_id>/art/<card_id>", methods=["DELETE"])
+def remove_art(set_id: str, card_id: str):
+    try:
+        base = _get_base_dir()
+        sm = SetManager.open(str(base / set_id))
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+    old_filename = sm.get_art(card_id)
+    if old_filename:
+        old_path = sm.art_dir / old_filename
+        if old_path.exists():
+            old_path.unlink()
+    sm.remove_art(card_id)
+    return jsonify({"success": True})
+
+
+# ─── Helpers ──────────────────────────────────────────────────────────
+
+@api_bp.route("/sets/<set_id>/manifest", methods=["POST"])
+def save_manifest(set_id: str):
+    data = request.get_json(silent=True) or {}
+    try:
+        sm = _get_set(set_id)
+        m = sm.manifest
+        for key in ("id", "name", "version", "author", "description", "engine_version"):
+            if key in data:
+                m[key] = data[key]
+        sm.save_manifest()
+        return jsonify({"success": True})
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+
+def _mana_display(mana_dict: dict) -> str:
+    if not mana_dict:
+        return ""
+    parts = []
+    for mt, val in mana_dict.items():
+        key = mt.value if hasattr(mt, 'value') else str(mt)
+        if val > 0:
+            label = "Y" if key == "any" else key[0].upper()
+            parts.append(f"{label}{val}")
+    return " ".join(parts)