voidcli 0.1.0__py3-none-any.whl

void/__init__.py

@@ -0,0 +1 @@
+""" VOID APP SRC CODE """

void/controllers/__init__.py

@@ -0,0 +1 @@
+"""Controllers module"""

void/controllers/activity.py

@@ -0,0 +1,44 @@
+import sqlite3
+
+from void.models.activity import Activity
+
+
+class ActivityController:
+
+    def get_activities(self) -> list[tuple]:
+        with Activity() as ac:
+            raw_activities = ac.get_active_activities()
+            activities = []
+            for item in raw_activities:
+                activities.append((item['id'], item['activity'], item['category']))
+            return activities
+
+    def get_activities_by_category(self, category_id):
+        with Activity() as ac:
+            raw_activities = ac.get_activities_by_category(category_id)
+            activities = []
+            for item in raw_activities:
+                activities.append((item["id"], item['name']))
+            return activities
+
+    def create_activity(self, activity, category_id) -> bool:
+        """Return False when the name is already used in that category."""
+        with Activity() as ac:
+            try:
+                ac.create_activity(activity, category_id)
+            except sqlite3.IntegrityError:
+                return False
+        return True
+
+    def update_activity(self, activity_id, activity, category_id) -> bool:
+        """Return False when the name is already used in that category."""
+        with Activity() as ac:
+            try:
+                ac.update_activity(activity_id, activity, category_id)
+            except sqlite3.IntegrityError:
+                return False
+        return True
+
+    def suspend_activity(self, activity_id):
+        with Activity() as ac:
+            ac.suspend_activity(activity_id)

void/controllers/category.py

@@ -0,0 +1,30 @@
+import sqlite3
+
+from void.models.category import Category
+
+
+class CategoryController:
+    def get_categories_for_activities(self) -> list[tuple]:
+        with Category() as ca:
+            raw_categories = ca.get_active_categories_for_activities()
+            categories = []
+            for item in raw_categories:
+                categories.append((item['category'], item['id']))
+            return categories
+
+    def get_categories(self) -> list[tuple]:
+        with Category() as ca:
+            raw_categories = ca.get_active_categories()
+            categories = []
+            for item in raw_categories:
+                categories.append((item['category'],))
+            return categories
+
+    def create_category(self, category) -> bool:
+        """Return False when a category with that name already exists."""
+        with Category() as ca:
+            try:
+                ca.create_category(category)
+            except sqlite3.IntegrityError:
+                return False
+        return True

void/controllers/note.py

@@ -0,0 +1,47 @@
+from void.controllers.activity import ActivityController
+from void.controllers.category import CategoryController
+from void.models.note import Note
+
+
+class NoteController:
+
+    def __init__(self):
+        self.category_ctrl = CategoryController()
+        self.activity_ctrl = ActivityController()
+
+
+    def get_activities_by_category(self):
+        active_categories = self.category_ctrl.get_categories_for_activities()
+        categories_and_activities = []
+        for cat in active_categories:
+            category, id = cat
+            activities = self.activity_ctrl.get_activities_by_category(category_id=id)
+            data = (id, category, activities)
+            categories_and_activities.append(data)
+        return categories_and_activities
+
+    def get_activities(self):
+        """Every active activity as (id, name, category)."""
+        return self.activity_ctrl.get_activities()
+
+    def get_activity_total(self):
+        return len(self.get_activities())
+
+    def save_note(self, date_str, activities):
+        with Note() as note:
+            note_id = note.save_note(date_str)
+            for activity in activities:
+                activity_info, activity_note = activity
+                self.save_note_details(note_id, activity_info, activity_note)
+
+    def save_note_details(self, note_id, activity_info, activity_note):
+        with Note() as note:
+            note.save_note_detail(note_id, activity_info, activity_note)
+
+    def get_day_note(self, date_str):
+        with Note() as note:
+            return note.get_day_note(date_str)
+
+    def get_notes(self):
+        with Note() as note:
+            return note.get_notes()

void/database/__init__.py

@@ -0,0 +1,16 @@
+"""Database module """
+
+from void.database.connection import DB_PATH, Connection
+
+
+def initialize_database():
+    """Create void.db and its schema the first time the app runs.
+
+    Does nothing once void.db already exists, so it's safe to call on
+    every startup.
+    """
+    if DB_PATH.exists():
+        return
+
+    with Connection() as db:
+        db.create_tables()

void/database/connection.py

@@ -0,0 +1,59 @@
+import sqlite3
+from pathlib import Path
+
+DB_PATH = Path(__file__).parent / "void.db"
+
+
+class Connection:
+    def __init__(self):
+        """Connect to void.db and configure results as name-accessible rows."""
+        self.db_path = DB_PATH
+        self.tables_script = Path(__file__).parent /  "init_tables.sql"
+        self.test_data_script = Path(__file__).parent / "test_data.sql"
+
+        self.connection = sqlite3.connect(self.db_path)
+        self.connection.row_factory = sqlite3.Row
+        self.cursor = self.connection.cursor()
+
+    def __enter__(self):
+        """Allow `with Connection() as db:`; returns this instance."""
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        """Close the connection when the `with` block ends, even on error."""
+        self.close()
+
+    def create_tables(self):
+        """Run init_tables.sql to create the schema. Safe to call more than
+        once, every statement uses IF NOT EXISTS."""
+        with open(self.tables_script) as f:
+            sql = f.read()
+            self.cursor.executescript(sql)
+            self.connection.commit()
+
+    def load_test_data(self):
+        """Run test_data.sql to populate sample rows."""
+        with open(self.test_data_script) as f:
+            sql = f.read()
+            self.cursor.executescript(sql)
+            self.connection.commit()
+
+    def querying(self, sql, params=()):
+        """Run a parameterized SELECT and return the matching rows.
+
+        params fills any `?` placeholders in sql, keeping values out of the
+        SQL string itself (avoids SQL injection).
+        """
+        self.cursor.execute(sql, params)
+        return self.cursor.fetchall()
+
+    def execute(self, sql, params=()):
+        """Run a parameterized INSERT/UPDATE/DELETE, commit, and return the
+        id of the inserted row (lastrowid; meaningless for UPDATE/DELETE)."""
+        self.cursor.execute(sql, params)
+        self.connection.commit()
+        return self.cursor.lastrowid
+
+    def close(self):
+        """Close the database connection."""
+        self.connection.close()

void/database/init_tables.sql

@@ -0,0 +1,47 @@
+PRAGMA foreign_keys = ON;
+
+CREATE TABLE IF NOT EXISTS categories(
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    name TEXT NOT NULL,
+    is_active INTEGER DEFAULT 1,
+    date_created TEXT DEFAULT (datetime('now'))
+);
+
+CREATE UNIQUE INDEX IF NOT EXISTS ux_categories_name
+    ON categories(name) WHERE is_active = 1;
+
+CREATE TABLE IF NOT EXISTS void_note(
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    note_date TEXT NOT NULL,
+    is_active INTEGER DEFAULT 1,
+    date_created TEXT DEFAULT (datetime('now'))
+);
+
+CREATE UNIQUE INDEX IF NOT EXISTS ux_void_note_note_date
+    ON void_note(note_date) WHERE is_active = 1;
+
+CREATE TABLE IF NOT EXISTS activities(
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  name TEXT NOT NULL,
+  is_active INTEGER DEFAULT 1,
+  date_created TEXT DEFAULT (datetime('now')),
+  category_id INTEGER NOT NULL,
+  FOREIGN KEY (category_id)
+    REFERENCES categories (id)
+);
+
+CREATE UNIQUE INDEX IF NOT EXISTS ux_activities_name_category
+    ON activities(name, category_id) WHERE is_active = 1;
+
+CREATE TABLE IF NOT EXISTS void_note_details (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  notes TEXT,
+  is_active INTEGER DEFAULT 1,
+  date_created TEXT DEFAULT (datetime('now')),
+  void_note_id INTEGER NOT NULL,
+  activity_id INTEGER NOT NULL,
+    FOREIGN KEY (void_note_id)
+    REFERENCES void_note (id),
+    FOREIGN KEY (activity_id)
+    REFERENCES activities(id)
+);

void/main.py

@@ -0,0 +1,153 @@
+from textual import on
+from textual.app import App, ComposeResult
+from textual.widgets import Footer, Header, TabbedContent, TabPane
+
+from void.database import initialize_database
+from void.views.activity import ActivitiesView
+from void.views.collection import CollectionView
+from void.views.day_note import DayNote
+from void.views.note import NoteView
+from void.views.note_form import NoteForm
+from void.views.welcome import WelcomeScreen
+
+
+class VoidApp(App):
+
+    CSS = """
+        /* LAYOUT */
+        .header{
+            dock: top;
+            height: auto;
+            padding: 1 2 0 2;
+            border-bottom: solid $primary;
+        }
+        .main_container{
+            padding: 1 2;
+        }
+        .card_grid{
+            grid-columns: 1fr;
+            height: auto;
+        }
+
+        /* TITLES */
+        .module_title{
+            text-style: bold;
+        }
+        .section_title{
+            text-style: bold;
+            color: $text-muted;
+        }
+        #counter{
+            color: $text-muted;
+        }
+        .empty_state{
+            color: $text-muted;
+            padding: 1 0;
+        }
+
+        /* CARDS */
+        .note_card{
+            height: auto;
+            padding: 0 2;
+            border: round $primary;
+        }
+        .note_card Label{
+            width: 100%;
+        }
+
+        /* LOGGED ACTIVITY ENTRY */
+        .entry_card{
+            height: auto;
+            margin: 0 0 1 0;
+            padding: 0 0 0 2;
+            border-left: thick $primary;
+        }
+        .entry_card Label{
+            width: 100%;
+        }
+        .entry_title{
+            text-style: bold;
+        }
+        .entry_note{
+            color: $text-muted;
+        }
+        .entry_empty{
+            color: $text-muted;
+            text-style: italic;
+        }
+
+        /* CENTERED STATE SCREENS */
+        .state_screen{
+            height: 1fr;
+            align: center middle;
+        }
+        .state_card{
+            width: 60;
+            max-width: 100%;
+            height: auto;
+            padding: 1 2;
+            border: round $panel;
+        }
+        .state_card Label{
+            width: 100%;
+            text-align: center;
+        }
+        .state_card_success{
+            border: round $success;
+        }
+        .state_title{
+            text-style: bold;
+        }
+        .state_success{
+            color: $success;
+        }
+        .state_muted{
+            color: $text-muted;
+        }
+        .state_hint{
+            color: $text-muted;
+            padding: 0 0 1 0;
+        }
+    """
+
+    def compose(self) -> ComposeResult:
+        yield Header(icon="🧠")
+
+        with TabbedContent(initial="void_note"):
+
+            with TabPane("VOID NOTE", id="void_note"):
+                yield NoteView()
+
+            with TabPane("VOID DAY", id="void_day_note"):
+                yield DayNote()
+
+            with TabPane("VOID COLLECTION", id="void_collection"):
+                yield CollectionView()
+
+            with TabPane("VOID ACTIVITIES", id="void_activities"):
+                yield ActivitiesView()
+
+
+        yield Footer()
+
+    @on(NoteForm.Saved)
+    async def on_note_saved(self) -> None:
+        await self.query_one(DayNote).recompose()
+        await self.query_one(CollectionView).recompose()
+        self.query_one(TabbedContent).active = "void_day_note"
+
+    @on(ActivitiesView.Changed)
+    async def on_activities_changed(self) -> None:
+        await self.query_one(NoteView).recompose()
+
+    def on_mount(self) -> None:
+        self.title = "VOID"
+        self.sub_title = "Vital Offline Information Diary"
+        self.push_screen(WelcomeScreen())
+
+def run() -> None:
+    initialize_database()
+    VoidApp().run()
+
+if __name__ == "__main__":
+    run()

void/models/__init__.py

@@ -0,0 +1 @@
+"""Models module"""

void/models/activity.py

@@ -0,0 +1,68 @@
+from void.database.connection import Connection
+
+
+class Activity:
+
+    def __enter__(self):
+        """Allow `with Activity() as activity:`; returns this instance."""
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        """Close the model when the `with` block ends, even on error."""
+
+    def get_active_activities(self):
+        with Connection() as db:
+            sql = """
+                SELECT
+                    activities.id as "id",
+                    activities.name as "activity",
+                    categories.name as "category"
+                FROM activities
+                INNER JOIN
+                    categories on categories.id = activities.category_id
+                WHERE activities.is_active == 1
+                AND
+                    categories.is_active == 1;"""
+            result = db.querying(sql)
+            return result
+
+    def get_activities_by_category(self, category_id):
+        with Connection() as db:
+            sql = """
+                SELECT
+                    activities.id as "id",
+                    activities.name as "name"
+                FROM activities
+                WHERE
+                    activities.category_id = ?
+                AND
+                    activities.is_active = 1
+            """
+            result = db.querying(sql, (category_id,))
+            return result
+
+    def create_activity(self, activity, category_id):
+        with Connection() as db:
+            data = (activity, category_id)
+            sql = "INSERT INTO activities (name, category_id) VALUES(?, ?)"
+            db.execute(sql, data)
+
+    def update_activity(self, activity_id, activity, category_id):
+        with Connection() as db:
+            data = (activity, category_id, activity_id)
+            sql = """
+                UPDATE activities
+                SET name = ?, category_id = ?
+                WHERE id = ?
+            """
+            db.execute(sql, data)
+
+    def suspend_activity(self, activity_id):
+            with Connection() as db:
+                data = (activity_id,)
+                sql = """
+                    UPDATE activities
+                    SET is_active = 0
+                    WHERE id = ?
+                """
+                db.execute(sql, data)

void/models/category.py

@@ -0,0 +1,40 @@
+from void.database.connection import Connection
+
+
+class Category:
+
+    def __enter__(self):
+        """Allow `with Category() as category:`; returns this instance."""
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+          """Close the model when the `with` block ends, even on error."""
+
+    def get_active_categories_for_activities(self):
+        with Connection() as db:
+            sql = """
+                SELECT
+                    categories.id as "id",
+                    categories.name as "category"
+                FROM categories
+                WHERE categories.is_active = 1
+            """
+            result = db.querying(sql)
+            return result
+
+    def get_active_categories(self):
+        with Connection() as db:
+            sql = """
+                SELECT
+                    categories.name as "category"
+                FROM categories
+                WHERE categories.is_active = 1
+            """
+            result = db.querying(sql)
+            return result
+
+    def create_category(self, category):
+        with Connection() as db:
+            data = (category,)
+            sql = "INSERT INTO categories (name) VALUES(?)"
+            db.execute(sql, data)

void/models/note.py

@@ -0,0 +1,64 @@
+
+from void.database.connection import Connection
+
+
+class Note:
+
+    def __enter__(self):
+        """Allow `with Note() as note:`; returns this instance."""
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+          """Close the model when the `with` block ends, even on error."""
+
+    def save_note(self, date_str):
+        with Connection() as db:
+            data = (date_str,)
+            sql = """
+                INSERT INTO
+                    void_note(note_date)
+                VALUES(?)
+            """
+            return db.execute(sql, data)
+
+    def save_note_detail(self, note_id, activity_info, activity_note):
+        activity_id, _ = activity_info.split("::")
+        with Connection() as db:
+            data = (activity_note, note_id, activity_id)
+            sql = """
+                INSERT INTO
+                    void_note_details(notes,  void_note_id, activity_id)
+                VALUES(?, ?, ?)
+            """
+            return db.execute(sql, data)
+
+    NOTE_SQL = """
+        SELECT
+            void_note.id as "note_id",
+            void_note.note_date as "note_date",
+            void_note_details.id as "detail_id",
+            activities.id as "activity_id",
+            activities.name as "activity",
+            categories.name as "category",
+            void_note_details.notes as "notes"
+        FROM void_note
+        INNER JOIN
+            void_note_details
+                ON void_note_details.void_note_id = void_note.id
+        INNER JOIN
+            activities ON activities.id = void_note_details.activity_id
+        INNER JOIN
+            categories ON categories.id = activities.category_id
+        WHERE void_note.is_active = 1
+        AND void_note_details.is_active = 1
+    """
+
+    def get_day_note(self, date_str):
+        with Connection() as db:
+            sql = self.NOTE_SQL + " AND void_note.note_date = ? ORDER BY categories.name, activities.name"
+            return db.querying(sql, (date_str,))
+
+    def get_notes(self):
+        """Every saved note detail, newest day first."""
+        with Connection() as db:
+            return db.querying(self.NOTE_SQL + " ORDER BY void_note.note_date DESC, void_note_details.id")

void/views/__init__.py

@@ -0,0 +1 @@
+""" APP VIEWS"""