Examtracker 1.1.0__tar.gz

examtracker-1.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Samuel Huwiler
+
+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.

examtracker-1.1.0/PKG-INFO

@@ -0,0 +1,159 @@
+Metadata-Version: 2.4
+Name: Examtracker
+Version: 1.1.0
+Summary: A Python exam tracker for the Lernphase .It allows you to keep track of all exams you have completed and the scores you achieved.
+Author-email: Samuel Huwiler <samuel.huwiler@gmx.ch>
+License: MIT License
+        
+        Copyright (c) 2026 Samuel Huwiler
+        
+        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.
+        
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: textual
+Requires-Dist: sqlalchemy
+Requires-Dist: flask-sqlalchemy
+Requires-Dist: pydantic
+Requires-Dist: pydantic-settings
+Requires-Dist: pathlib
+Requires-Dist: pyyaml
+Dynamic: license-file
+
+[![MIT License](https://img.shields.io/badge/License-MIT-green.svg)](https://choosealicense.com/licenses/mit/)
+<a href="https://github.com/psf/black"><img alt="Code style: black" src="https://img.shields.io/badge/code%20style-black-000000.svg"></a>
+![Python Version from PEP 621 TOML](https://img.shields.io/python/required-version-toml?tomlFilePath=https%3A%2F%2Fraw.githubusercontent.com%2FSamhuw8a%2FExamtracker%2Fmaster%2Fpyproject.toml&color=d8634c)
+
+# Examtracker
+
+A Python exam tracker for the **"Lernphase"**.  
+It allows you to keep track of all exams you have completed and the scores you achieved.
+
+The application uses:
+
+- SQLAlchemy + SQLite for data storage  
+- Textual as the TUI backend  
+
+---
+
+# Installation
+
+### Clone the repository
+
+```bash
+git clone https://github.com/Samhuw8a/Examtracker.git
+```
+
+### Install the project
+
+```bash
+cd Examtracker
+python -m pip install -e .
+```
+
+> You might need to add the `--break-system-packages` flag to the install command
+
+---
+
+# Usage
+
+Once installed, you can start the program with:
+
+```bash
+examtracker
+```
+
+---
+
+# Configuration
+
+You can change the location of the database file using a configuration file.
+
+By default, the program searches for:
+
+```
+~/.config/examtracker/config.yml
+```
+
+---
+
+## Default `config.yml`
+
+<details>
+<summary>default configuration</summary>
+
+```yaml
+database_path: "<path to repo>/data/test.db"
+css_path: "<path to repo>/data/style.css"
+```
+
+</details>
+
+---
+
+## Environment Variables
+
+All configuration options can also be set using environment variables.
+
+You can even change the location where the program searches for the configuration file.
+
+<details>
+<summary>Environment variables</summary>
+
+```env
+EXAMTRACKER_DATABASE_PATH=/tmp/test.db
+EXAMTRACKER_CSS_PATH=/tmp/style.css
+EXAMTRACKER_CONFIG=/tmp/config.yml
+```
+
+</details>
+
+Environment variables override values defined in `config.yml`.
+
+---
+
+# Database Schema
+
+### `exams`
+- `id`
+- `name`
+- `max_points`
+- `scored_points`
+- `class_id`
+
+### `classes`
+- `id`
+- `name`
+- `semester_id`
+
+### `semester`
+- `id`
+- `name` (unique)
+
+---
+
+# TODO
+
+- [x] Handle SQL errors  
+- [x] Initialize database  
+- [x] Configuration file support  
+- [x] Abort edit and add screens  
+- [x] Cross-platform config discovery  
+- [ ] Improve CSS  

examtracker-1.1.0/README.md

@@ -0,0 +1,120 @@
+[![MIT License](https://img.shields.io/badge/License-MIT-green.svg)](https://choosealicense.com/licenses/mit/)
+<a href="https://github.com/psf/black"><img alt="Code style: black" src="https://img.shields.io/badge/code%20style-black-000000.svg"></a>
+![Python Version from PEP 621 TOML](https://img.shields.io/python/required-version-toml?tomlFilePath=https%3A%2F%2Fraw.githubusercontent.com%2FSamhuw8a%2FExamtracker%2Fmaster%2Fpyproject.toml&color=d8634c)
+
+# Examtracker
+
+A Python exam tracker for the **"Lernphase"**.  
+It allows you to keep track of all exams you have completed and the scores you achieved.
+
+The application uses:
+
+- SQLAlchemy + SQLite for data storage  
+- Textual as the TUI backend  
+
+---
+
+# Installation
+
+### Clone the repository
+
+```bash
+git clone https://github.com/Samhuw8a/Examtracker.git
+```
+
+### Install the project
+
+```bash
+cd Examtracker
+python -m pip install -e .
+```
+
+> You might need to add the `--break-system-packages` flag to the install command
+
+---
+
+# Usage
+
+Once installed, you can start the program with:
+
+```bash
+examtracker
+```
+
+---
+
+# Configuration
+
+You can change the location of the database file using a configuration file.
+
+By default, the program searches for:
+
+```
+~/.config/examtracker/config.yml
+```
+
+---
+
+## Default `config.yml`
+
+<details>
+<summary>default configuration</summary>
+
+```yaml
+database_path: "<path to repo>/data/test.db"
+css_path: "<path to repo>/data/style.css"
+```
+
+</details>
+
+---
+
+## Environment Variables
+
+All configuration options can also be set using environment variables.
+
+You can even change the location where the program searches for the configuration file.
+
+<details>
+<summary>Environment variables</summary>
+
+```env
+EXAMTRACKER_DATABASE_PATH=/tmp/test.db
+EXAMTRACKER_CSS_PATH=/tmp/style.css
+EXAMTRACKER_CONFIG=/tmp/config.yml
+```
+
+</details>
+
+Environment variables override values defined in `config.yml`.
+
+---
+
+# Database Schema
+
+### `exams`
+- `id`
+- `name`
+- `max_points`
+- `scored_points`
+- `class_id`
+
+### `classes`
+- `id`
+- `name`
+- `semester_id`
+
+### `semester`
+- `id`
+- `name` (unique)
+
+---
+
+# TODO
+
+- [x] Handle SQL errors  
+- [x] Initialize database  
+- [x] Configuration file support  
+- [x] Abort edit and add screens  
+- [x] Cross-platform config discovery  
+- [ ] Improve CSS  

examtracker-1.1.0/pyproject.toml

@@ -0,0 +1,31 @@
+[build-system]
+# A list of packages that are needed to build your package:
+requires = ["setuptools"] # REQUIRED if [build-system] table is used
+# The name of the Python object that frontends will use to perform the build:
+build-backend = "setuptools.build_meta" # If not defined, then legacy behavior can happen.
+
+
+[project]
+name = "Examtracker" # REQUIRED, is the only field that cannot be marked as dynamic.
+version = "1.1.0" # REQUIRED, although can be dynamic
+description = "A Python exam tracker for the Lernphase .It allows you to keep track of all exams you have completed and the scores you achieved."
+
+readme = "README.md"
+
+requires-python = ">=3.13"
+license = { file = "LICENSE" }
+
+authors = [{ name = "Samuel Huwiler", email = "samuel.huwiler@gmx.ch" }]
+
+dynamic = ["dependencies"]
+
+[tool.setuptools.dynamic]
+dependencies = {file = ["requirements.txt"]}
+optional-dependencies = {dev = { file = ["dev_requirements.txt"] }}
+
+
+[tool.setuptools.package-data]
+examtracker = ["data/*"]
+
+[project.scripts]
+examtracker = "examtracker.__main__:main"

examtracker-1.1.0/requirements.txt

@@ -0,0 +1,7 @@
+textual
+sqlalchemy
+flask-sqlalchemy
+pydantic
+pydantic-settings
+pathlib
+pyyaml

examtracker-1.1.0/setup.cfg

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

examtracker-1.1.0/src/Examtracker.egg-info/PKG-INFO

@@ -0,0 +1,159 @@
+Metadata-Version: 2.4
+Name: Examtracker
+Version: 1.1.0
+Summary: A Python exam tracker for the Lernphase .It allows you to keep track of all exams you have completed and the scores you achieved.
+Author-email: Samuel Huwiler <samuel.huwiler@gmx.ch>
+License: MIT License
+        
+        Copyright (c) 2026 Samuel Huwiler
+        
+        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.
+        
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: textual
+Requires-Dist: sqlalchemy
+Requires-Dist: flask-sqlalchemy
+Requires-Dist: pydantic
+Requires-Dist: pydantic-settings
+Requires-Dist: pathlib
+Requires-Dist: pyyaml
+Dynamic: license-file
+
+[![MIT License](https://img.shields.io/badge/License-MIT-green.svg)](https://choosealicense.com/licenses/mit/)
+<a href="https://github.com/psf/black"><img alt="Code style: black" src="https://img.shields.io/badge/code%20style-black-000000.svg"></a>
+![Python Version from PEP 621 TOML](https://img.shields.io/python/required-version-toml?tomlFilePath=https%3A%2F%2Fraw.githubusercontent.com%2FSamhuw8a%2FExamtracker%2Fmaster%2Fpyproject.toml&color=d8634c)
+
+# Examtracker
+
+A Python exam tracker for the **"Lernphase"**.  
+It allows you to keep track of all exams you have completed and the scores you achieved.
+
+The application uses:
+
+- SQLAlchemy + SQLite for data storage  
+- Textual as the TUI backend  
+
+---
+
+# Installation
+
+### Clone the repository
+
+```bash
+git clone https://github.com/Samhuw8a/Examtracker.git
+```
+
+### Install the project
+
+```bash
+cd Examtracker
+python -m pip install -e .
+```
+
+> You might need to add the `--break-system-packages` flag to the install command
+
+---
+
+# Usage
+
+Once installed, you can start the program with:
+
+```bash
+examtracker
+```
+
+---
+
+# Configuration
+
+You can change the location of the database file using a configuration file.
+
+By default, the program searches for:
+
+```
+~/.config/examtracker/config.yml
+```
+
+---
+
+## Default `config.yml`
+
+<details>
+<summary>default configuration</summary>
+
+```yaml
+database_path: "<path to repo>/data/test.db"
+css_path: "<path to repo>/data/style.css"
+```
+
+</details>
+
+---
+
+## Environment Variables
+
+All configuration options can also be set using environment variables.
+
+You can even change the location where the program searches for the configuration file.
+
+<details>
+<summary>Environment variables</summary>
+
+```env
+EXAMTRACKER_DATABASE_PATH=/tmp/test.db
+EXAMTRACKER_CSS_PATH=/tmp/style.css
+EXAMTRACKER_CONFIG=/tmp/config.yml
+```
+
+</details>
+
+Environment variables override values defined in `config.yml`.
+
+---
+
+# Database Schema
+
+### `exams`
+- `id`
+- `name`
+- `max_points`
+- `scored_points`
+- `class_id`
+
+### `classes`
+- `id`
+- `name`
+- `semester_id`
+
+### `semester`
+- `id`
+- `name` (unique)
+
+---
+
+# TODO
+
+- [x] Handle SQL errors  
+- [x] Initialize database  
+- [x] Configuration file support  
+- [x] Abort edit and add screens  
+- [x] Cross-platform config discovery  
+- [ ] Improve CSS  

examtracker-1.1.0/src/Examtracker.egg-info/SOURCES.txt

@@ -0,0 +1,23 @@
+LICENSE
+README.md
+pyproject.toml
+requirements.txt
+src/Examtracker.egg-info/PKG-INFO
+src/Examtracker.egg-info/SOURCES.txt
+src/Examtracker.egg-info/dependency_links.txt
+src/Examtracker.egg-info/entry_points.txt
+src/Examtracker.egg-info/requires.txt
+src/Examtracker.egg-info/top_level.txt
+src/examtracker/__init__.py
+src/examtracker/__main__.py
+src/examtracker/app.py
+src/examtracker/database.py
+src/examtracker/database_scheme.py
+src/examtracker/main.py
+src/examtracker/py.typed
+src/examtracker/settings.py
+src/examtracker/data/style.css
+src/examtracker/screens/classscreen.py
+src/examtracker/screens/examscreen.py
+src/examtracker/screens/semesterscreen.py
+src/examtracker/textual_utils/vimtable.py

examtracker-1.1.0/src/Examtracker.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

examtracker-1.1.0/src/Examtracker.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+examtracker = examtracker.__main__:main

examtracker-1.1.0/src/Examtracker.egg-info/requires.txt

@@ -0,0 +1,7 @@
+textual
+sqlalchemy
+flask-sqlalchemy
+pydantic
+pydantic-settings
+pathlib
+pyyaml

examtracker-1.1.0/src/Examtracker.egg-info/top_level.txt

@@ -0,0 +1 @@
+examtracker

examtracker-1.1.0/src/examtracker/__main__.py

@@ -0,0 +1,4 @@
+from .main import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

examtracker-1.1.0/src/examtracker/app.py

@@ -0,0 +1,39 @@
+from sqlalchemy import Engine  # type:ignore
+from sqlalchemy.orm import Session
+from textual.app import App, ComposeResult
+
+from examtracker.screens.semesterscreen import SemesterScreen
+from examtracker.settings import Settings
+
+
+class ExamTracker(App):
+    BINDINGS = [
+        ("q", "quit", "Quit"),
+        ("ctrl+c", "quit"),
+    ]
+    # CSS_PATH = "/Users/samuel/Repositories/Examtracker/data/style.css"
+
+    def compose(self) -> ComposeResult:
+        yield SemesterScreen()
+
+    def on_mount(self) -> None:
+        self.push_screen(SemesterScreen())
+        self.stylesheet.read(self.config.css_path)
+
+    def __init__(self, db_engine: Engine, config: Settings, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self.db_session = Session(db_engine)
+        self.config = config
+
+    def quit(self) -> None:
+        self.db_session.commit()
+        self.db_session.close()
+        self.exit()
+
+    def pop_screen(self):
+        # Only pop if there is more than 1 screen (not including the blank screen)
+        if len(self.screen_stack) > 2:
+            super().pop_screen()
+        else:
+            # Ignore pop on base screen
+            pass

examtracker-1.1.0/src/examtracker/data/style.css

@@ -0,0 +1,30 @@
+DataTable {
+    border-title-align: center;
+    border-title-style: bold;
+    margin: 5;
+    padding: 2;
+    width: 75%;
+    border: white;
+}
+
+Screen {
+    position: relative;
+    align: center top;
+    margin: 3;
+}
+
+Vertical {
+    margin: 5;
+    align: center top; 
+    width:75%;
+}
+
+Input {
+    width: 75%;
+}
+
+
+Label {
+    width: 75%;
+    padding: 1;
+}

examtracker-1.1.0/src/examtracker/database.py

@@ -0,0 +1,111 @@
+"""
+Database related functions for getting and adding entries
+"""
+
+from typing import List
+
+from sqlalchemy import Engine, create_engine, inspect  # type:ignore
+from sqlalchemy.orm import Session
+
+from examtracker.database_scheme import Base, Class, Exam, Semester
+
+
+def create_database_engine(path: str) -> Engine:
+    engine = create_engine("sqlite:///" + path, echo=False)
+    inspector = inspect(engine)
+
+    if not inspector.get_table_names():
+        create_tables(engine)
+
+    return engine
+
+
+def create_tables(engine: Engine) -> None:
+    Base.metadata.create_all(engine)
+
+
+def get_semester_by_name(session: Session, name: str) -> Semester:
+    return session.query(Semester).filter_by(name=name).one()
+
+
+def add_semester(session: Session, name: str) -> None:
+    semester_obj = Semester(name=name)
+    session.add(semester_obj)
+    session.flush
+
+
+def get_class_by_id(session: Session, class_id: int) -> Class:
+    return session.query(Class).filter_by(class_id=class_id).one()
+
+
+def get_exam_by_id(session: Session, exam_id: int) -> Exam:
+    return session.query(Exam).filter_by(exam_id=exam_id).one()
+
+
+def add_class_to_semester(
+    session: Session, class_name: str, semster_obj: Semester
+) -> None:
+    class_obj = Class(name=class_name, semester_id=semster_obj.semester_id)
+    session.add(class_obj)
+    session.flush()
+
+
+def add_exam_to_class(
+    session: Session, name: str, max_points: int, scored_points: int, class_obj: Class
+) -> None:
+    exam_obj = Exam(
+        name=name,
+        max_points=max_points,
+        scored_points=scored_points,
+        class_id=class_obj.class_id,
+    )
+    session.add(exam_obj)
+    session.flush()
+
+
+def get_all_exams_for_class(session: Session, class_obj: Class) -> List[Exam]:
+    return session.query(Exam).filter_by(class_id=class_obj.class_id).all()
+
+
+def get_all_semester(session: Session) -> List[Semester]:
+    return session.query(Semester).all()
+
+
+def get_all_classes_for_semester(
+    session: Session, semster_obj: Semester
+) -> List[Class]:
+    return session.query(Class).filter_by(semester_id=semster_obj.semester_id).all()
+
+
+def remove_semester_by_name(session: Session, name: str) -> None:
+    sem = get_semester_by_name(session, name)
+    session.delete(sem)  # type:ignore
+
+
+def remove_class_by_id(session: Session, id: int) -> None:
+    cls = get_class_by_id(session, id)
+    session.delete(cls)  # type:ignore
+
+
+def remove_exam_by_id(session: Session, exam_id: int) -> None:
+    exam_obj = get_exam_by_id(session, exam_id)
+    session.delete(exam_obj)  # type: ignore
+
+
+def main() -> int:
+    engine: Engine = create_database_engine("test.db")
+    # create_tables(engine)
+    session = Session(engine)
+    # # add_semester(session, "FS25")
+    # # remove_semester_by_name(session, "FS25")
+    # # print(get_all_semester(session))
+    # sem = get_semester_by_name(session, "HS24")
+    # add_class_to_semester(session, "Eprog", sem)
+    # # cls = get_class_by_name(session,"Eprog")
+    # # print(get_all_exams_for_class(session, cls))
+    session.commit()
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

examtracker-1.1.0/src/examtracker/database_scheme.py

@@ -0,0 +1,59 @@
+"""
+Defining the database tables and entries
+"""
+
+from typing import List
+
+from sqlalchemy import ForeignKey, String
+from sqlalchemy.orm import (
+    DeclarativeBase,
+    Mapped,  # type:ignore
+    mapped_column,
+    relationship,
+)
+
+
+class Base(DeclarativeBase):
+    pass
+
+
+class Exam(Base):
+    __tablename__ = "exams"
+    exam_id: Mapped[int] = mapped_column(primary_key=True)
+    name: Mapped[str] = mapped_column(String(30))
+    max_points: Mapped[int]
+    scored_points: Mapped[int]
+    class_id: Mapped[int] = mapped_column(ForeignKey("classes.class_id"))
+    class_: Mapped["Class"] = relationship(back_populates="exams")  # type:ignore
+
+    def __repr__(self) -> str:
+        return f"ID:{self.exam_id}|name:{self.name}|{self.max_points}|{self.scored_points}|Class:{self.class_id}"
+
+
+class Class(Base):
+    __tablename__ = "classes"
+    class_id: Mapped[int] = mapped_column(primary_key=True)
+    name: Mapped[str] = mapped_column(String(30))
+    semester_id: Mapped[int] = mapped_column(ForeignKey("semester.semester_id"))
+    semester: Mapped["Semester"] = relationship(back_populates="classes")  # type:ignore
+
+    exams: Mapped[List["Exam"]] = relationship(
+        back_populates="class_",
+        cascade="all, delete-orphan",
+    )  # type: ignore
+
+    def __repr__(self) -> str:
+        return f"ID:{self.class_id}|name:{self.name}|Semester:{self.semester_id}"
+
+
+class Semester(Base):
+    __tablename__ = "semester"
+    semester_id: Mapped[int] = mapped_column(primary_key=True)
+    name: Mapped[str] = mapped_column(String(30), unique=True)
+    classes: Mapped[List["Class"]] = relationship(
+        back_populates="semester",
+        cascade="all, delete-orphan",
+    )  # type: ignore
+
+    def __repr__(self) -> str:
+        return f"ID:{self.semester_id}|name:{self.name}"

examtracker-1.1.0/src/examtracker/main.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+from examtracker.app import ExamTracker
+from examtracker.database import create_database_engine
+from examtracker.settings import Settings
+
+
+def main() -> int:
+    config: Settings = Settings()
+    db_engine = create_database_engine(config.database_path)
+    app = ExamTracker(db_engine, config)
+    app.run()
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

examtracker-1.1.0/src/examtracker/screens/classscreen.py

@@ -0,0 +1,123 @@
+from sqlalchemy.exc import IntegrityError
+from sqlalchemy.orm import Session
+from textual import on
+from textual.app import ComposeResult, Screen
+from textual.containers import Vertical
+from textual.widgets import DataTable, Footer, Header, Input, Label
+
+from examtracker.database import (
+    add_class_to_semester,
+    get_all_classes_for_semester,
+    get_semester_by_name,
+    remove_class_by_id,
+)
+from examtracker.screens.examscreen import ExamScreen
+from examtracker.textual_utils.vimtable import VimTable
+
+
+class AddClassScreen(Screen):
+    BINDINGS = [
+        ("escape", "app.pop_screen", "Cancel"),
+    ]
+
+    def __init__(self, semester_name: str, **kwargs):
+        super().__init__(**kwargs)
+        self.semester_name = semester_name
+        self.db_session = self.app.db_session  # type: ignore
+
+    def compose(self) -> ComposeResult:
+        yield Header()
+        with Vertical():
+            yield Label(f"Add Class to: {self.semester_name}")
+            # Inputs for the class
+            self.name_input = Input(placeholder="Class Name", id="name")
+            yield self.name_input
+        yield Footer()
+
+    def on_mount(self) -> None:
+        self.name_input.focus()
+
+    # Submit on Enter from any Input
+    @on(Input.Submitted)
+    def submit(self) -> None:
+        name = self.name_input.value.strip()
+        if not name:
+            return  # Require class name
+
+        semester = get_semester_by_name(self.db_session, self.semester_name)
+
+        # Add the class
+        try:
+            add_class_to_semester(self.db_session, name, semester)  # type: ignore
+            self.db_session.commit()
+        except IntegrityError:
+            # TODO add error message for unique constraint
+            self.db_session.rollback()
+            pass
+
+        # Pop the screen and return
+        self.app.pop_screen()
+
+
+class ClassScreen(Screen):
+    """
+    Shows all the classes for a given semester
+    """
+
+    BINDINGS = [
+        ("escape", "app.pop_screen", "Back"),
+        ("a", "add", "Add semester"),
+        ("ctrl+r", "remove", "Remove semester"),
+    ]
+
+    def __init__(self, semester_name: str) -> None:
+        super().__init__()
+        self.db_session: Session = self.app.db_session  # type: ignore
+        self.semester_name = semester_name
+
+    def compose(self) -> ComposeResult:
+        yield Header()
+        self.class_table: VimTable = VimTable()
+        self.class_table.add_columns("ID", "Name")
+        self.class_table.cursor_type = "row"
+        self.class_table.border_title = f"Classes for: {self.semester_name}"
+        yield self.class_table
+        yield Footer()
+
+    def on_mount(self) -> None:
+        self.refresh_table()
+
+    def action_add(self) -> None:
+        self.app.push_screen(AddClassScreen(self.semester_name))
+
+    def action_remove(self) -> None:
+        row_index = self.class_table.cursor_row
+        if row_index is None:
+            return
+        if not self.class_table.is_valid_row_index(row_index):
+            return
+        row = self.class_table.get_row_at(row_index)
+        class_id = row[0]
+        remove_class_by_id(self.db_session, class_id)
+        self.db_session.commit()
+        self.refresh_table()
+
+    def refresh_table(self) -> None:
+        semester = get_semester_by_name(self.db_session, self.semester_name)
+
+        self.class_table.clear()
+        for cls in get_all_classes_for_semester(self.db_session, semester):
+            self.class_table.add_row(cls.class_id, cls.name)
+
+    def on_screen_resume(self) -> None:
+        # Called when returning from AddSemesterScreen
+        self.refresh_table()
+
+    @on(VimTable.RowSelected)
+    def open_exam(self, event: DataTable.RowSelected) -> None:
+        row_index = self.class_table.cursor_row
+        if row_index is None:
+            return
+
+        class_id = self.class_table.get_row_at(row_index)[0]
+        self.app.push_screen(ExamScreen(class_id))

examtracker-1.1.0/src/examtracker/screens/examscreen.py

@@ -0,0 +1,209 @@
+from textual import on
+from textual.app import ComposeResult, Screen
+from textual.containers import Vertical
+from textual.widgets import DataTable, Footer, Header, Input, Label
+
+from examtracker.database import (
+    add_exam_to_class,
+    get_all_exams_for_class,
+    get_class_by_id,
+    get_exam_by_id,
+    remove_exam_by_id,
+)
+from examtracker.textual_utils.vimtable import VimTable
+
+
+class EditExamScreen(Screen):
+    BINDINGS = [
+        ("escape", "app.pop_screen", "Cancel"),
+    ]
+
+    def __init__(self, exam_id: int, **kwargs):
+        super().__init__(**kwargs)
+        self.exam_id = exam_id
+        self.db_session = self.app.db_session  # type:ignore
+
+    def compose(self) -> ComposeResult:
+        yield Header()
+        with Vertical():
+            yield Label("Edit Exam")
+            # Inputs for the class
+            self.name_input = Input(placeholder="Exam Name", id="name")
+            yield self.name_input
+
+            self.max_input = Input(placeholder="Exam Max Points (optional)", id="max")
+            yield self.max_input
+            self.score_input = Input(
+                placeholder="Exam Scored Points (optional)", id="score"
+            )
+            yield self.score_input
+
+        yield Footer()
+
+    def on_mount(self) -> None:
+        exam = get_exam_by_id(self.db_session, self.exam_id)
+
+        self.name_input.value = exam.name
+        self.max_input.value = str(exam.max_points)
+        self.score_input.value = str(exam.scored_points)
+
+        self.name_input.focus()
+
+    @on(Input.Submitted)
+    def submit(self) -> None:
+        name = self.name_input.value.strip()
+        if not name:
+            return  # Require class name
+
+        # Optional exam points
+        try:
+            max_points = int(self.max_input.value.strip())
+        except ValueError:
+            # Ignore invalid numbers for now
+            max_points = 0
+
+        try:
+            scored_points = int(self.score_input.value.strip())
+        except ValueError:
+            # Ignore invalid numbers for now
+            scored_points = 0
+
+        exam = get_exam_by_id(self.db_session, self.exam_id)
+        exam.name = name
+        exam.max_points = max_points
+        exam.scored_points = scored_points
+
+        self.db_session.commit()
+
+        self.app.pop_screen()
+
+
+class AddExamScreen(Screen):
+    BINDINGS = [
+        ("escape", "app.pop_screen", "Cancel"),
+    ]
+
+    def __init__(self, class_id: int, **kwargs):
+        super().__init__(**kwargs)
+        self.class_id = class_id
+        self.db_session = self.app.db_session  # type: ignore
+        self.class_name = get_class_by_id(self.db_session, self.class_id).name
+
+    def compose(self) -> ComposeResult:
+        yield Header()
+        with Vertical():
+            yield Label(f"Add Exam to: {self.class_name}")
+            # Inputs for the class
+            self.name_input = Input(placeholder="Exam Name", id="name")
+            yield self.name_input
+
+            # Optional exam fields
+            self.max_input = Input(placeholder="Exam Max Points (optional)", id="max")
+            yield self.max_input
+            self.score_input = Input(
+                placeholder="Exam Scored Points (optional)", id="score"
+            )
+            yield self.score_input
+
+        yield Footer()
+
+    def on_mount(self) -> None:
+        self.name_input.focus()
+
+    @on(Input.Submitted)
+    def submit(self) -> None:
+        name = self.name_input.value.strip()
+        if not name:
+            return  # Require class name
+
+        try:
+            max_points = int(self.max_input.value.strip())
+        except ValueError:
+            # Ignore invalid numbers for now
+            max_points = 0
+
+        try:
+            scored_points = int(self.score_input.value.strip())
+        except ValueError:
+            # Ignore invalid numbers for now
+            scored_points = 0
+
+        class_obj = get_class_by_id(self.db_session, self.class_id)
+
+        # Add the class
+        add_exam_to_class(self.db_session, name, max_points, scored_points, class_obj)
+        self.db_session.commit()
+
+        # Pop the screen and return
+        self.app.pop_screen()
+
+
+class ExamScreen(Screen):
+    BINDINGS = [
+        ("escape", "app.pop_screen", "Back"),
+        ("a", "add", "Add exam"),
+        ("ctrl+r", "remove", "Remove exam"),
+    ]
+
+    def __init__(self, class_id: int, **kwargs):
+        super().__init__(**kwargs)
+        self.class_id = class_id
+        self.db_session = self.app.db_session  # type: ignore
+        self.class_name = get_class_by_id(self.db_session, self.class_id).name
+
+    def compose(self) -> ComposeResult:
+        yield Header()
+
+        self.exam_table: VimTable = VimTable()
+        self.exam_table.add_columns("ID", "Name", "Max_points", "Scored_points", "%")
+        self.exam_table.cursor_type = "row"
+        self.exam_table.border_title = f"Exams completed for: {self.class_name}"
+        yield self.exam_table
+
+        yield Footer()
+
+    def on_mount(self) -> None:
+        self.refresh_table()
+        self.exam_table.focus()
+
+    def action_add(self) -> None:
+        self.app.push_screen(AddExamScreen(self.class_id))
+
+    def action_remove(self) -> None:
+        row_index = self.exam_table.cursor_row
+        if row_index is None:
+            return
+        if not self.exam_table.is_valid_row_index(row_index):
+            return
+        row = self.exam_table.get_row_at(row_index)
+        exam_id = row[0]
+        remove_exam_by_id(self.db_session, exam_id)
+        self.db_session.commit()
+        self.refresh_table()
+
+    def refresh_table(self) -> None:
+        class_obj = get_class_by_id(self.db_session, self.class_id)
+
+        self.exam_table.clear()
+        for cls in get_all_exams_for_class(self.db_session, class_obj):
+            if cls.max_points == 0:
+                proc = 0.0
+            else:
+                proc = (cls.scored_points / cls.max_points) * 100
+
+            self.exam_table.add_row(
+                cls.exam_id, cls.name, cls.max_points, cls.scored_points, proc
+            )
+
+    def on_screen_resume(self) -> None:
+        # Called when returning from AddSemesterScreen
+        self.refresh_table()
+
+    @on(VimTable.RowSelected)
+    def edit_exam(self, event: DataTable.RowSelected) -> None:
+        row_index = self.exam_table.cursor_row
+        if row_index is None:
+            return
+
+        exam_id = self.exam_table.get_row_at(row_index)[0]
+        self.app.push_screen(EditExamScreen(exam_id))

examtracker-1.1.0/src/examtracker/screens/semesterscreen.py

@@ -0,0 +1,108 @@
+from sqlalchemy.exc import IntegrityError
+from textual import on
+from textual.app import ComposeResult, Screen
+from textual.containers import Vertical
+from textual.widgets import DataTable, Footer, Header, Input, Label
+
+from examtracker.database import add_semester, get_all_semester, remove_semester_by_name
+from examtracker.screens.classscreen import ClassScreen
+from examtracker.textual_utils.vimtable import VimTable
+
+
+class AddSemesterScreen(Screen):
+    BINDINGS = [
+        ("escape", "app.pop_screen", "Cancel"),
+    ]
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.db_session = self.app.db_session  # type: ignore
+
+    def compose(self) -> ComposeResult:
+        yield Header()
+        with Vertical():
+            yield Label("Add new Semester")
+            self.input = Input(
+                placeholder="Semester name (e.g. Fall 2026)",
+                id="semester_name",
+            )
+            yield self.input
+        yield Footer()
+
+    def on_mount(self) -> None:
+        self.input.focus()
+
+    @on(Input.Submitted)
+    def input_submitted(self, event: Input.Submitted) -> None:
+        self.submit()
+
+    def submit(self) -> None:
+        name = self.input.value.strip()
+        if not name:
+            return
+        try:
+            add_semester(self.db_session, name)
+            self.db_session.commit()
+        except IntegrityError:
+            # TODO add error message for unique constraint
+            self.db_session.rollback()
+            pass
+
+        self.app.pop_screen()
+
+
+class SemesterScreen(Screen):
+    BINDINGS = [
+        ("a", "add", "Add semester"),
+        ("ctrl+r", "remove", "Remove semester"),
+    ]
+
+    def __init__(self) -> None:
+        super().__init__()
+
+    def compose(self) -> ComposeResult:
+        yield Header()
+        self.semester_table: VimTable = VimTable()
+        self.semester_table.add_columns("Name")
+        self.semester_table.cursor_type = "row"
+        self.semester_table.border_title = "Semester Overview"
+        yield self.semester_table
+        yield Footer()
+
+    def on_mount(self) -> None:
+        self.db_session = self.app.db_session  # type: ignore
+        self.refresh_table()
+        self.semester_table.focus()
+
+    def refresh_table(self) -> None:
+        self.semester_table.clear()
+        for sem in get_all_semester(self.db_session):
+            self.semester_table.add_row(sem.name)
+
+    def action_add(self) -> None:
+        self.app.push_screen(AddSemesterScreen())
+
+    def action_remove(self) -> None:
+        row_index = self.semester_table.cursor_row
+        if row_index is None:
+            return
+        if not self.semester_table.is_valid_row_index(row_index):
+            return
+        row = self.semester_table.get_row_at(row_index)
+        semester_name = row[0]
+
+        remove_semester_by_name(self.db_session, semester_name)  # type:ignore
+        self.db_session.commit()
+        self.refresh_table()
+
+    def on_screen_resume(self) -> None:
+        self.refresh_table()
+
+    @on(VimTable.RowSelected)
+    def open_class(self, event: DataTable.RowSelected) -> None:
+        row_index = self.semester_table.cursor_row
+        if row_index is None:
+            return
+
+        semester_name = self.semester_table.get_row_at(row_index)[0]
+        self.app.push_screen(ClassScreen(semester_name))

examtracker-1.1.0/src/examtracker/settings.py

@@ -0,0 +1,92 @@
+from __future__ import annotations
+
+import os
+import sys
+from importlib.resources import files
+from pathlib import Path
+from typing import Any, Dict
+
+import yaml  # type: ignore
+from platformdirs import PlatformDirs
+from pydantic import Field
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+APP_NAME = "examtracker"
+APP_AUTHOR = "Samuel Huwiler"
+
+dirs = PlatformDirs(appname=APP_NAME, appauthor=APP_AUTHOR)
+
+
+def get_config_dir() -> Path:
+    if sys.platform == "darwin":
+        # Force ~/.config instead of ~/Library/Application Support
+        return Path.home() / ".config" / APP_NAME
+    else:
+        # Linux & Windows default
+        return Path(dirs.user_config_dir)
+
+
+def get_default_database_path() -> Path:
+    """Return a writable database path in the user data directory."""
+
+    db_dir = get_config_dir()
+    db_dir.mkdir(parents=True, exist_ok=True)
+    return db_dir / "examtracker.db"
+
+
+def get_default_css_path() -> Path:
+    """Return the path to the CSS inside the package data folder."""
+    return Path(files("examtracker").joinpath("data/style.css"))  # type:ignore
+
+
+def yaml_config_settings_source(settings_cls) -> Dict[str, Any]:
+    config_path = os.getenv("EXAMTRACKER_CONFIG")
+
+    if config_path:
+        path = Path(config_path).expanduser()
+        if path.exists():
+            with open(path, "r") as f:
+                return yaml.safe_load(f) or {}
+
+    user_config = get_config_dir() / "config.yml"
+
+    if user_config.exists():
+        with open(user_config, "r") as f:
+            return yaml.safe_load(f) or {}
+
+    return {}
+
+
+class Settings(BaseSettings):
+    database_path: str = Field(default_factory=lambda: str(get_default_database_path()))
+    css_path: str = Field(default_factory=lambda: str(get_default_css_path()))
+    model_config = SettingsConfigDict(
+        env_prefix="EXAMTRACKER_",
+        extra="ignore",
+    )
+
+    @classmethod
+    def settings_customise_sources(
+        cls,
+        settings_cls,
+        init_settings,
+        env_settings,
+        dotenv_settings,
+        file_secret_settings,
+    ):
+        return (
+            init_settings,
+            env_settings,
+            lambda: yaml_config_settings_source(settings_cls),
+            dotenv_settings,
+            file_secret_settings,
+        )
+
+
+def main() -> int:
+    print(Settings())
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

examtracker-1.1.0/src/examtracker/textual_utils/vimtable.py

@@ -0,0 +1,11 @@
+from textual.widgets import DataTable
+
+
+class VimTable(DataTable):
+
+    BINDINGS = [
+        ("j", "cursor_down"),
+        ("k", "cursor_up"),
+        ("l", "select_cursor"),
+        ("h", "app.pop_screen"),
+    ]