quizzy 0.3.1__tar.gz → 0.5.0__tar.gz

{quizzy-0.3.1 → quizzy-0.5.0}/.gitignore

@@ -136,3 +136,5 @@ dmypy.json
 .pyre/
 
 playground/
+
+/*.json

{quizzy-0.3.1 → quizzy-0.5.0}/CHANGELOG.md

@@ -1,6 +1,14 @@
 
 # Changelog
 
+## v0.5.0
+
+* Save state of unfinished quizzes to continue at a later point
+
+## v0.4.0
+
+* Add `--serve` flag to serve the application in a browser
+
 ## v0.3.1
 
 * Fixed the lockfile for this version

{quizzy-0.3.1 → quizzy-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quizzy
-Version: 0.3.1
+Version: 0.5.0
 Summary: A Python TUI quiz app
 Author-email: Jonas Ehrlich <jonas.ehrlich@gmail.com>
 License-Expression: MIT
@@ -8,6 +8,7 @@ License-File: LICENSE
 Requires-Python: >=3.10
 Requires-Dist: pydantic>=2.10.3
 Requires-Dist: pyyaml>=6.0.2
+Requires-Dist: textual-serve>=1.1.1
 Requires-Dist: textual>=1.0.0
 Description-Content-Type: text/markdown
 
@@ -63,7 +64,7 @@ uv run quizzy examples/quizzy.yaml
 Serve on a webserver using textual:
 
 ``` sh
-uv run textual serve "uv run quizzy examples/quizzy.yaml"
+uvx quizzy --serve examples/quizzy.yaml
 ```
 
 Run in development mode:

{quizzy-0.3.1 → quizzy-0.5.0}/README.md

@@ -50,7 +50,7 @@ uv run quizzy examples/quizzy.yaml
 Serve on a webserver using textual:
 
 ``` sh
-uv run textual serve "uv run quizzy examples/quizzy.yaml"
+uvx quizzy --serve examples/quizzy.yaml
 ```
 
 Run in development mode:

{quizzy-0.3.1 → quizzy-0.5.0}/pyproject.toml

@@ -1,12 +1,17 @@
 
 [project]
 name = "quizzy"
-version = "0.3.1"
+version = "0.5.0"
 description = "A Python TUI quiz app"
 authors = [{ name = "Jonas Ehrlich", email = "jonas.ehrlich@gmail.com" }]
 readme = "README.md"
 requires-python = ">=3.10"
-dependencies = ["pydantic>=2.10.3", "pyyaml>=6.0.2", "textual>=1.0.0"]
+dependencies = [
+    "pydantic>=2.10.3",
+    "pyyaml>=6.0.2",
+    "textual-serve>=1.1.1",
+    "textual>=1.0.0",
+]
 license = "MIT"
 
 [project.scripts]

quizzy-0.5.0/quizzy/__main__.py

@@ -0,0 +1,3 @@
+from quizzy.app import main
+
+main()

{quizzy-0.3.1 → quizzy-0.5.0}/quizzy/app.py

@@ -2,22 +2,18 @@ from __future__ import annotations
 
 import argparse
 import pathlib
+import shlex
+import sys
+from typing import NoReturn
 
 from textual import app, binding, containers, log, message, reactive, screen, widgets
+from textual_serve import server
 
 from quizzy import __version__, models
 
 NoCorrectAnswerType = type("NoCorrectAnswerType", (object,), {})
 NoCorrectAnswer = NoCorrectAnswerType()
 
-
-def get_arg_parser() -> argparse.ArgumentParser:
-    parser = argparse.ArgumentParser(prog=__name__.split(".")[0], description="A terminal quiz app")
-    parser.add_argument("--version", action="version", version=f"%(prog)s {__version__}")
-    parser.add_argument("quizfile", type=pathlib.Path, help="Quiz file")
-    return parser
-
-
 QuestionScreenResult = models.Team | NoCorrectAnswerType | None
 
 
@@ -193,7 +189,7 @@ class QuestionButton(widgets.Button):
         def wait_for_result(team: QuestionScreenResult) -> None:
             if team is None:
                 return
-            # First, disable the button to prevent multiple clicks
+
             self.disabled = True
             self.question.answered = True
             if isinstance(team, NoCorrectAnswerType):
@@ -230,12 +226,9 @@ class QuestionBoard(containers.HorizontalGroup):
 class QuizzyApp(app.App[None]):
     CSS_PATH = "quizzy.tcss"
 
-    def __init__(self) -> None:
+    def __init__(self, config: models.Config) -> None:
         super().__init__()
-        parser = get_arg_parser()
-        namespace = parser.parse_args()
-
-        self.config = models.load_config(namespace.quizfile)
+        self.config = config
         self.scoreboard_widget = Scoreboard(self.config.teams)
 
     def compose(self) -> app.ComposeResult:
@@ -248,3 +241,67 @@ class QuizzyApp(app.App[None]):
 
     def on_mount(self) -> None:
         self.theme = "textual-light"
+
+
+def get_arg_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog=__name__.split(".")[0],
+        description="A quiz app to run in the terminal or the browser",
+        epilog=(
+            "When an unfinished quiz is closed, the state is saved to a timestamped quiz file in the current working "
+            "directory."
+        ),
+    )
+
+    parser.add_argument("--version", action="version", version=f"%(prog)s {__version__}")
+
+    serve_group = parser.add_argument_group("Serve options")
+    serve_group.add_argument("--serve", action="store_true", help="Serve the app through the browser")
+    serve_group.add_argument("--host", default="localhost", help="Host to serve the app on")
+    serve_group.add_argument("--port", type=int, default=8000, help="Port to serve the app on")
+
+    parser.add_argument("quizfile", type=pathlib.Path, help="Quiz file")
+    return parser
+
+
+def serve_app(host: str, port: int) -> None:
+    """Serve the app through textual-serve.
+
+    :param host: Host to serve the app on
+    :param port: Port to serve the app on
+    """
+    # The --serve flag is set, drop it from the args and serve the app instead through textual-serve
+    args = list(sys.argv)
+    args.remove("--serve")
+
+    server.Server(shlex.join(args), host=host, port=port).serve()
+
+
+def run_app(
+    quiz_file: pathlib.Path,
+) -> None:
+    """Run the app in the terminal.
+
+    :param quizfile: File to use for this quiz
+    """
+    try:
+        config = models.load_config(quiz_file)
+    except Exception as e:
+        print(f"Error loading quiz file: {e}", file=sys.stderr)
+        sys.exit(1)
+    app = QuizzyApp(config)
+    try:
+        app.run()
+    finally:
+        models.dump_config_if_not_finished(config)
+
+
+def main() -> NoReturn:
+    parser = get_arg_parser()
+    namespace = parser.parse_args()
+
+    if namespace.serve:
+        serve_app(namespace.host, namespace.port)
+    else:
+        run_app(namespace.quizfile)
+    sys.exit(0)

quizzy-0.5.0/quizzy/models.py

@@ -0,0 +1,103 @@
+from __future__ import annotations
+
+import datetime
+import json
+import pathlib
+from typing import Annotated, Any, Self
+
+import pydantic
+import yaml
+from pydantic import Field, model_validator
+from pydantic.dataclasses import dataclass
+
+
+@dataclass
+class Team:
+    name: str = Field(min_length=2)
+    score: int = Field(default=0, ge=0)
+    id: str = Field(init=False)
+
+    def __post_init__(self) -> None:
+        self.id = self.name.replace(" ", "-").lower()
+
+    def __str__(self) -> str:
+        return self.name
+
+
+def is_multiple_of_100(v: int) -> int:
+    if v % 100 != 0:
+        raise ValueError("Value must be a multiple of 100")
+    return v
+
+
+@dataclass
+class Question:
+    question: str = Field(description="The question to ask. Markdown is supported.")
+    answer: str = Field(description="The answer to the question. Markdown is supported.")
+    value: Annotated[int, pydantic.AfterValidator(is_multiple_of_100)] = Field(
+        gt=0, description="The value of the question in points. Must be a multiple of 100."
+    )
+    answered: bool = Field(default=False, description="Whether the question has been answered already.")
+
+    def __str__(self) -> str:
+        return self.question
+
+
+@dataclass
+class Category:
+    name: str = Field(description="The name of the category.")
+    questions: list[Question] = Field(max_length=5, description="The questions in this category.")
+
+    @model_validator(mode="after")
+    def sort_questions(self) -> Self:
+        """Sort the questions in this category by their value."""
+
+        self.questions.sort(key=lambda q: q.value)
+        return self
+
+
+@dataclass
+class Config:
+    categories: list[Category] = Field(max_length=5, description="The categories in the quiz.")
+    teams: list[Team] = Field(default=[Team("Team 1"), Team("Team 2")], description="The teams in the quiz.")
+
+    def is_finished(self) -> bool:
+        for category in self.categories:
+            for question in category.questions:
+                if not question.answered:
+                    return False
+        return True
+
+
+def _get_dict(path: pathlib.Path) -> dict[str, Any]:
+    """Get the dictionary from a file.
+
+    :param path: Path of the file to load.
+    :raises ValueError: Raised if the file format is not supported.
+    :return: Dictionary with the contents of the file.
+    """
+    with path.open() as f:
+        if path.suffix == ".json":
+            return json.load(f)
+        if path.suffix in {".yml", ".yaml"}:
+            return yaml.safe_load(f)
+        raise ValueError(f"Unsupported file format: {path.suffix}")
+
+
+def load_config(path: pathlib.Path) -> Config:
+    raw = _get_dict(path)
+    return Config(**raw)
+
+
+def dump_config_if_not_finished(config: Config) -> None:
+    """Dump the config if any of the questions is not answered yet.
+
+    :param config: _description_
+    """
+    if config.is_finished():
+        return
+    p = pathlib.Path() / f"quizzy-run-{datetime.datetime.now().strftime('%Y%m%d-%H%M%S')}.json"
+    print(f"This quiz is not finished yet. Saving current state to '{p}'.")
+    print("This file can be re-used later.")
+    with p.open("wb") as f:
+        f.write(pydantic.TypeAdapter(Config).dump_json(config))

{quizzy-0.3.1 → quizzy-0.5.0}/uv.lock

@@ -840,12 +840,13 @@ wheels = [
 
 [[package]]
 name = "quizzy"
-version = "0.3.1"
+version = "0.5.0"
 source = { editable = "." }
 dependencies = [
     { name = "pydantic" },
     { name = "pyyaml" },
     { name = "textual" },
+    { name = "textual-serve" },
 ]
 
 [package.dev-dependencies]
@@ -863,6 +864,7 @@ requires-dist = [
     { name = "pydantic", specifier = ">=2.10.3" },
     { name = "pyyaml", specifier = ">=6.0.2" },
     { name = "textual", specifier = ">=1.0.0" },
+    { name = "textual-serve", specifier = ">=1.1.1" },
 ]
 
 [package.metadata.requires-dev]

quizzy-0.3.1/quizzy/__main__.py

@@ -1,9 +0,0 @@
-from quizzy.app import QuizzyApp
-
-
-def main() -> None:
-    QuizzyApp().run()
-
-
-if __name__ == "__main__":
-    main()

quizzy-0.3.1/quizzy/models.py

@@ -1,59 +0,0 @@
-from __future__ import annotations
-
-import pathlib
-from typing import Self
-
-import yaml
-from pydantic import Field, model_validator
-from pydantic.dataclasses import dataclass
-
-
-@dataclass
-class Team:
-    name: str = Field(min_length=2)
-    score: int = Field(default=0, ge=0)
-    id: str = Field(init=False)
-
-    def __post_init__(self) -> None:
-        self.id = self.name.replace(" ", "-").lower()
-
-    def __str__(self) -> str:
-        return self.name
-
-
-@dataclass
-class Question:
-    question: str
-    answer: str
-    value: int = Field(gt=0)
-    answered: bool = False
-
-    def __str__(self) -> str:
-        return self.question
-
-
-@dataclass
-class Category:
-    name: str
-    questions: list[Question] = Field(max_length=5)
-
-    @model_validator(mode="after")
-    def sort_questions(self) -> Self:
-        """Sort the questions in this category by their value."""
-
-        self.questions.sort(key=lambda q: q.value)
-        return self
-
-
-@dataclass
-class Config:
-    categories: list[Category] = Field(max_length=5)
-    teams: list[Team] = Field(default=[Team("Team 1"), Team("Team 2")])
-    # TODO: Support random questions
-
-
-def load_config(path: pathlib.Path) -> Config:
-    with path.open() as f:
-        raw = yaml.safe_load(f)
-
-    return Config(**raw)