voidcli 0.1.0__py3-none-any.whl

void/views/activity.py

@@ -0,0 +1,247 @@
+from typing import override
+
+from textual import on
+from textual.app import ComposeResult
+from textual.containers import Horizontal, Vertical
+from textual.message import Message
+from textual.widgets import Button, DataTable, Input, Label, Select, Static
+
+from void.controllers.activity import ActivityController
+from void.controllers.category import CategoryController
+
+
+class ActivitiesView(Static):
+
+    class Changed(Message):
+        """Posted when the activity list changes, so NoteForm can re-render."""
+
+    DEFAULT_CSS = """
+        #category_module{
+            height: 1fr;
+            padding: 0 2 0 0;
+            width: 30%;
+            border-right: solid $primary;
+        }
+
+        #activity_module{
+            padding: 0 0 0 2;
+            height: 1fr;
+            width: 70%;
+        }
+
+        .field_label{
+            margin: 1 0 0 0;
+        }
+
+        #add_category{
+            margin: 1 0;
+        }
+
+        #activity_form{
+            height: auto;
+            margin: 0 0 1 0;
+        }
+
+        #activity_form_cta_container{
+            height: auto;
+            margin: 1 0 0 0;
+        }
+
+        #activity_form_cta_container Button{
+            margin: 0 1 0 0;
+        }
+
+        #activities_table{
+            height: 1fr;
+        }
+
+        #activity_id{
+            display: none;
+        }
+
+    """
+
+    @override
+    def __init__(self) -> None:
+        super().__init__()
+        self.ctrl = ActivityController()
+        self.categoriesCtrl = CategoryController()
+
+    @override
+    def compose(self) -> ComposeResult:
+        with Vertical(classes="header"):
+            yield Label("VOID ACTIVITIES", classes="module_title")
+            yield Label(self.counter_text(), id="counter")
+        with Horizontal(classes="main_container"):
+            with Vertical(id="category_module"):
+                yield Label("CATEGORIES", classes="module_title")
+                yield Label("New Category", classes="field_label")
+                yield Input(placeholder="Add a new category", id="new_category")
+                yield Button(label="ADD",  flat=True, id="add_category")
+                yield DataTable(id="categories_table")
+            with Vertical(id="activity_module"):
+                with Vertical(id="activity_form"):
+                    yield Label("ACTIVITIES", classes="module_title")
+                    yield Label("Activity", classes="field_label")
+                    yield Input(placeholder="Add a new activity", id="new_activity")
+                    yield Label("Select a category", classes="field_label")
+                    yield Select([], type_to_search=True, id="category_select")
+                    yield Input(id="activity_id", compact=True)
+                    with Horizontal(id="activity_form_cta_container"):
+                        yield Button(label="ADD",  flat=True, id="add_activity", variant="success")
+                        yield Button(label="UPDATE", flat=True, id="update_activity",variant="warning", disabled=True)
+                        yield Button(label="SUSPEND", flat=True, id="suspend_activity", variant="error", disabled=True)
+                        yield Button(label="CLEAR", flat=True, id="clear_activity_form", variant="default")
+                yield DataTable(id="activities_table", cursor_type="row")
+
+    def on_mount(self) -> None:
+        # Category inputs
+        self.add_category_input = self.query_one("#new_category", Input)
+        self.add_category_btn = self.query_one("#add_category", Button)
+        self.categories_table = self.query_one("#categories_table", DataTable)
+
+        # Activity inputs
+        self.add_activity_input = self.query_one("#new_activity", Input)
+        self.category_selector = self.query_one("#category_select", Select)
+        self.activity_id = self.query_one("#activity_id", Input)
+        self.add_activity_btn = self.query_one("#add_activity", Button)
+        self.update_activity_btn = self.query_one("#update_activity", Button)
+        self.suspend_activity_btn = self.query_one("#suspend_activity", Button)
+        self.clear_activity_form_btn = self.query_one("#clear_activity_form", Button)
+        self.activities_table = self.query_one("#activities_table", DataTable)
+
+        self.init_activities_table()
+        self.init_categories_selector()
+        self.init_categories_table()
+
+    def counter_text(self) -> str:
+        activities = len(self.ctrl.get_activities())
+        categories = len(self.categoriesCtrl.get_categories())
+        return f"{activities} activities in {categories} categories"
+
+    def update_counter(self) -> None:
+        self.query_one("#counter", Label).update(self.counter_text())
+
+    def init_activities_table(self):
+        activities = self.ctrl.get_activities()
+        self.activities_table.add_columns("ID","ACTIVITY", "CATEGORY")
+        self.activities_table.add_rows(activities)
+
+    def init_categories_selector(self):
+        self.category_selector.clear()
+        self.category_selector.set_options(self.categoriesCtrl.get_categories_for_activities())
+
+    def init_categories_table(self):
+        categories = self.categoriesCtrl.get_categories()
+        self.categories_table.add_columns("CATEGORY")
+        self.categories_table.add_rows(categories)
+
+    def update_activities(self):
+        activities = self.ctrl.get_activities()
+        self.activities_table.clear()
+        self.activities_table.add_rows(activities)
+        self.update_counter()
+
+    def update_categories(self):
+        categories = self.categoriesCtrl.get_categories()
+        self.categories_table.clear()
+        self.categories_table.add_rows(categories)
+        self.init_categories_selector()
+        self.update_counter()
+
+
+    @on(Button.Pressed, "#clear_activity_form")
+    def on_clear_activity_form(self) -> None:
+        self.clear_activity_form()
+
+    @on(Button.Pressed, "#add_activity")
+    def on_add_activity(self) -> None:
+        activity = self.add_activity_input.value
+        category_id = self.category_selector.value
+
+        if not activity:
+            self.notify("Activity must be set", severity="error")
+            return
+        if not category_id:
+            self.notify("Category must be set", severity="error")
+            return
+
+        if not self.ctrl.create_activity(activity, category_id):
+            self.notify(f"'{activity}' already exists in that category", severity="error")
+            return
+
+        self.add_activity_input.value = ""
+        self.category_selector.clear()
+        self.update_activities()
+        self.post_message(self.Changed())
+
+    @on(Button.Pressed, "#update_activity")
+    def on_update_activity(self) -> None:
+        activity = self.add_activity_input.value
+        activity_id = self.activity_id.value
+        category_id = self.category_selector.value
+
+        if not activity:
+            self.notify("Activity must be set", severity="error")
+            return
+        if not category_id:
+            self.notify("Category must be set", severity="error")
+            return
+
+        if not self.ctrl.update_activity(activity_id, activity, category_id):
+            self.notify(f"'{activity}' already exists in that category", severity="error")
+            return
+
+        self.update_activities()
+        self.clear_activity_form()
+        self.post_message(self.Changed())
+
+    @on(Button.Pressed, "#suspend_activity")
+    def on_suspend_activity(self) -> None:
+        activity_id = self.activity_id.value
+        self.ctrl.suspend_activity(activity_id)
+        self.clear_activity_form()
+        self.update_activities()
+        self.post_message(self.Changed())
+
+
+
+    @on(Button.Pressed, "#add_category")
+    def on_add_category(self) -> None:
+        category = self.add_category_input.value
+        if not category:
+            self.notify("Category must be set", severity="error")
+            return
+
+        if not self.categoriesCtrl.create_category(category):
+            self.notify(f"Category '{category}' already exists", severity="error")
+            return
+
+        self.add_category_input.value = ""
+        self.update_categories()
+
+    @on(DataTable.RowSelected, "#activities_table")
+    def on_activity_row_selected(self, event: DataTable.RowSelected) -> None:
+        row = event.data_table.get_row(event.row_key)
+        ac_id = row[0]
+        ac_name = row[1]
+        ac_category = row[2]
+
+        self.add_activity_input.value = ac_name
+        self.activity_id.value = str(ac_id)
+
+        categories = self.categoriesCtrl.get_categories_for_activities()
+        category_id = next((cid for name, cid in categories if name == ac_category), Select.BLANK)
+        self.category_selector.value = category_id
+
+        self.update_activity_btn.disabled = False
+        self.add_activity_btn.disabled = True
+        self.suspend_activity_btn.disabled = False
+
+    def clear_activity_form(self):
+        self.add_activity_input.value = ""
+        self.activity_id.value = ""
+        self.category_selector.clear()
+        self.update_activity_btn.disabled = True
+        self.add_activity_btn.disabled = False
+        self.suspend_activity_btn.disabled = True

void/views/collection.py

@@ -0,0 +1,52 @@
+from datetime import date
+from itertools import groupby
+from typing import override
+
+from textual.app import ComposeResult
+from textual.containers import Grid, Vertical, VerticalScroll
+from textual.widgets import Label, Static
+
+from void.controllers.note import NoteController
+
+
+class CollectionView(Static):
+
+    DEFAULT_CSS = """
+        .note_grid{
+            grid-size: 3;
+            grid-gutter: 1;
+        }
+        .note_card_date{
+            color: $text-muted;
+            padding: 0 0 1 0;
+        }
+    """
+
+    @override
+    def __init__(self) -> None:
+        super().__init__()
+        self.ctrl = NoteController()
+
+    @override
+    def compose(self) -> ComposeResult:
+        notes = self.ctrl.get_notes()
+        with Vertical(classes="header"):
+            yield Label("VOID COLLECTION", classes="module_title")
+        with VerticalScroll(classes="main_container"):
+            if not notes:
+                yield Label("No VOID NOTE saved yet.")
+                return
+            with Grid(classes="card_grid note_grid"):
+                for note_date, rows in groupby(notes, key=lambda row: row["note_date"]):
+                    with Vertical(classes="note_card"):
+                        yield Label(self.format_date(note_date), classes="note_card_date")
+                        for row in rows:
+                            with Vertical(classes="entry_card"):
+                                yield Label(row["activity"], classes="entry_title")
+                                if row["notes"]:
+                                    yield Label(row["notes"], classes="entry_note")
+                                else:
+                                    yield Label("No notes written.", classes="entry_empty")
+
+    def format_date(self, date_str):
+        return date.fromisoformat(date_str).strftime("%B %d, %Y").upper()

void/views/day_note.py

@@ -0,0 +1,101 @@
+from collections import Counter
+from datetime import date
+from itertools import groupby
+from typing import override
+
+from textual import on
+from textual.app import ComposeResult
+from textual.containers import Center, Horizontal, Vertical, VerticalScroll
+from textual.widgets import Button, Label, Static, TabbedContent
+
+from void.controllers.note import NoteController
+
+
+class DayNote(Static):
+
+    DEFAULT_CSS = """
+        .day_logged{
+            width: 2fr;
+        }
+        .day_pending{
+            width: 1fr;
+            padding: 0 0 0 2;
+        }
+        .day_pending Label{
+            width: 100%;
+        }
+        .pending_category{
+            color: $text-muted;
+            padding: 1 0 0 3;
+        }
+        .pending_item{
+            color: $text-disabled;
+            padding: 0 0 0 2;
+            border-left: thick $primary;
+        }
+    """
+
+    @override
+    def __init__(self) -> None:
+        super().__init__()
+        self.ctrl = NoteController()
+
+        self.today = date.today()  # noqa: DTZ011
+        self.date_str = self.today.strftime("%B %d, %Y").upper()
+
+    @override
+    def compose(self) -> ComposeResult:
+        day_note_data = self.ctrl.get_day_note(self.today.isoformat())
+        activities = self.ctrl.get_activities()
+        per_category = Counter(category for _, _, category in activities)
+
+        logged_ids = {row["activity_id"] for row in day_note_data}
+        pending = sorted(
+            (category, name)
+            for activity_id, name, category in activities
+            if activity_id not in logged_ids
+        )
+
+        with Vertical(classes="header"):
+            yield Label(self.date_str, classes="module_title")
+            yield Label(self.counter_text(len(day_note_data), len(activities)), id="counter")
+
+        if not day_note_data:
+            with Vertical(classes="state_screen"), Vertical(classes="state_card"):
+                yield Label("NOTHING LOGGED TODAY", classes="state_title")
+                yield Label("Write today's note to fill the void.", classes="state_hint")
+                with Center():
+                    yield Button("WRITE VOID NOTE", id="go_to_note", variant="primary", flat=True)
+            return
+
+        with Horizontal(classes="main_container"):
+            with VerticalScroll(classes="day_logged"):
+                for category, group in groupby(day_note_data, key=lambda row: row["category"]):
+                    rows = list(group)
+                    yield Label(
+                        f"── {category.upper()} · {len(rows)} of {per_category[category]} ",
+                        classes="section_title",
+                    )
+                    for row in rows:
+                        with Vertical(classes="entry_card"):
+                            yield Label(row["activity"], classes="entry_title")
+                            if row["notes"]:
+                                yield Label(row["notes"], classes="entry_note")
+                            else:
+                                yield Label("No notes written.", classes="entry_empty")
+
+            if pending:
+                with VerticalScroll(classes="day_pending"):
+                    yield Label(f"── NOT LOGGED · {len(pending)} ", classes="section_title")
+                    for category, group in groupby(pending, key=lambda item: item[0]):
+                        yield Label(category.upper(), classes="pending_category")
+                        for _, name in group:
+                            yield Label(name, classes="pending_item")
+
+    def counter_text(self, logged: int, total: int) -> str:
+        activities = "activity" if total == 1 else "activities"
+        return f"{logged} of {total} {activities} logged"
+
+    @on(Button.Pressed, "#go_to_note")
+    def on_go_to_note(self) -> None:
+        self.app.query_one(TabbedContent).active = "void_note"

void/views/note.py

@@ -0,0 +1,47 @@
+from datetime import date
+from typing import override
+
+from textual import on
+from textual.app import ComposeResult
+from textual.containers import Center, Vertical
+from textual.widgets import Button, Label, Static, TabbedContent
+
+from void.controllers.note import NoteController
+from void.views.note_form import NoteForm
+
+
+class NoteView(Static):
+
+
+   @override
+   def __init__(self) -> None:
+      super().__init__()
+      self.ctrl = NoteController()
+      self.today = date.today()  # noqa: DTZ011
+      self.date_str = self.today.strftime("%B %d, %Y").upper()
+
+
+   @override
+   def compose(self) -> ComposeResult:
+       created_note_of_the_day = self.ctrl.get_day_note(self.today.isoformat())
+       if created_note_of_the_day:
+           with Vertical(classes="state_screen"), Vertical(classes="state_card state_card_success"):
+               yield Label(self.date_str, classes="state_muted")
+               yield Label("VOID NOTE SAVED", classes="state_title state_success")
+               yield Label(self.hint_text(len(created_note_of_the_day)), classes="state_hint")
+               with Center():
+                   yield Button("SEE VOID DAY", id="go_to_day_note", variant="success", flat=True)
+       else:
+           yield NoteForm()
+
+   def hint_text(self, logged: int) -> str:
+       activities = "activity" if logged == 1 else "activities"
+       return f"{logged} {activities} logged today"
+
+   @on(Button.Pressed, "#go_to_day_note")
+   def on_go_to_day_note(self) -> None:
+       self.app.query_one(TabbedContent).active = "void_day_note"
+
+   @on(NoteForm.Saved)
+   async def on_note_saved(self) -> None:
+       await self.recompose()

void/views/note_form.py

@@ -0,0 +1,144 @@
+from datetime import date
+from typing import override
+
+from textual import on
+from textual.app import ComposeResult
+from textual.binding import Binding
+from textual.containers import Grid, Horizontal, Vertical, VerticalScroll
+from textual.message import Message
+from textual.widgets import Button, Checkbox, Input, Label, Static, TextArea
+
+from void.controllers.note import NoteController
+
+
+class NoteForm(Static):
+
+    class Saved(Message):
+        """Posted once the day's note is stored, so NoteView can swap to DayNote."""
+
+    BINDINGS = [Binding("ctrl+s", "save", "SAVE VOID NOTE", priority=True)]
+
+    DEFAULT_CSS = """
+        NoteForm{
+            layout: vertical;
+        }
+        .actions{
+            dock: bottom;
+            height: auto;
+            padding: 0 2 1 2;
+            align-horizontal: right;
+        }
+        #date_str{
+            display: none;
+        }
+
+        .category_block{
+            height: auto;
+            padding: 0 0 1 0;
+        }
+        .category_title{
+            text-style: bold;
+            color: $accent;
+            padding: 0 0 1 0;
+        }
+        .activity_grid{
+            grid-size: 2;
+            grid-gutter: 1 2;
+        }
+        .activity_card{
+            height: auto;
+            padding: 1 1;
+        }
+        .activity_card Checkbox{
+            width: 100%;
+        }
+        .activity_card TextArea{
+            height: 6;
+        }
+        .activity_handle{
+            display: none;
+        }
+    """
+
+    @override
+    def __init__(self) -> None:
+       super().__init__()
+       self.ctrl = NoteController()
+       self.activities_by_category_data = self.ctrl.get_activities_by_category()
+       self.activity_total = self.ctrl.get_activity_total()
+
+       self.today = date.today()  # noqa: DTZ011
+       self.date_str = self.today.strftime("%B %d, %Y").upper()
+       self.date_iso = self.today.isoformat()
+
+       day_note_data = self.ctrl.get_day_note(self.today.isoformat())
+
+       self.disable_add_note_btn = False
+       if day_note_data:
+           self.disable_add_note_btn = True
+
+
+
+    @override
+    def compose(self) -> ComposeResult:
+        with Vertical(classes="header"):
+            yield Label(self.date_str, classes="module_title")
+            yield Label(self.counter_text(0), id="counter")
+            yield Input(value=self.date_iso, id="date_str")
+        with Horizontal(classes="actions"):
+            yield Button("SAVE VOID NOTE", id="save_note_btn", variant="success", flat=True, disabled=self.disable_add_note_btn)
+        with VerticalScroll(classes="main_container"):
+            for _, category, activities in self.activities_by_category_data:
+                if activities:
+                    with Vertical(classes="category_block"):
+                        yield Label(f"── {category} ", classes="category_title")
+                        with Grid(classes="card_grid activity_grid"):
+                            for id, name in activities:
+                                handle = f"{id}::{self.handleize(name)}"
+                                with Vertical(classes="activity_card"):
+                                    yield Checkbox(label=name)
+                                    yield Input(value=handle, classes="activity_handle")
+                                    yield TextArea()
+
+    @on(Checkbox.Changed)
+    def on_activity_toggled(self) -> None:
+        self.query_one("#counter", Label).update(self.counter_text(self.count_check_elements()))
+
+    def counter_text(self, checked: int) -> str:
+        return f"{checked} of {self.activity_total} activities logged"
+
+    def action_save(self) -> None:
+        if not self.disable_add_note_btn:
+            self.on_save_note()
+
+    @on(Button.Pressed, "#save_note_btn")
+    def on_save_note(self) -> None:
+        if self.count_check_elements() == 0:
+            self.notify("Please check at least one activity to save", severity="warning")
+            return
+
+        checked_activities = []
+        for checkbox in self.query(Checkbox):
+            if checkbox.value:
+                parent_container = checkbox.query_ancestor(Vertical)
+                handle = parent_container.query_one(Input).value
+                note = parent_container.query_one(TextArea).text
+                checked_activities.append((handle, note))
+
+        self.save_note(checked_activities)
+
+    def save_note(self, activities):
+        date_str = self.query_one("#date_str", Input).value.strip()
+        self.ctrl.save_note(date_str, activities)
+        self.notify("VOID NOTE successfully saved", severity="information")
+        self.post_message(self.Saved())
+
+    def count_check_elements(self) -> int:
+        counter = 0
+        for checkbox in self.query(Checkbox):
+            if checkbox.value:
+               counter += 1
+        return counter
+
+    def handleize(self, string_to_handle):
+        return string_to_handle.lower().replace("'","").replace(" ", "-")

void/views/welcome.py

@@ -0,0 +1,72 @@
+from typing import override
+
+from textual.app import ComposeResult
+from textual.containers import Vertical
+from textual.events import Key
+from textual.screen import Screen
+from textual.widgets import Label, Rule
+
+LOGO = """\
+ █████   █████    ███████    █████ ██████████  
+░░███   ░░███   ███░░░░░███ ░░███ ░░███░░░░███ 
+ ░███    ░███  ███     ░░███ ░███  ░███   ░░███
+ ░███    ░███ ░███      ░███ ░███  ░███    ░███
+ ░░███   ███  ░███      ░███ ░███  ░███    ░███
+  ░░░█████░   ░░███     ███  ░███  ░███    ███ 
+    ░░███      ░░░███████░   █████ ██████████  
+     ░░░         ░░░░░░░    ░░░░░ ░░░░░░░░░░\
+"""
+
+
+AUTO_DISMISS = 1.75
+
+
+class WelcomeScreen(Screen[None]):
+
+    DEFAULT_CSS = """
+    .welcome_card{
+        width: 59;
+        max-width: 100%;
+        height: auto;
+        padding: 2 4;
+        border: round $primary;
+    }
+    .welcome_card Label{
+        width: 100%;
+        text-align: center;
+    }
+    .welcome_logo{
+        color: $primary;
+        text-style: bold;
+    }
+    .welcome_card Rule{
+        color: $primary;
+    }
+    .welcome_tagline{
+        padding: 0 0 1 0;
+        color: $text-muted;
+    }
+    .welcome_hint{
+        color: $accent;
+        text-style: italic;
+    }
+    """
+
+    @override
+    def compose(self) -> ComposeResult:
+        with Vertical(classes="state_screen"), Vertical(classes="welcome_card"):
+            yield Label(LOGO, classes="welcome_logo")
+            yield Rule(line_style="heavy")
+            yield Label("VITAL OFFLINE INFORMATION DIARY", classes="welcome_tagline")
+            yield Label("press any key to skip", classes="welcome_hint")
+
+    def on_mount(self) -> None:
+        self.set_timer(AUTO_DISMISS, self.close)
+
+    def on_key(self, _: Key) -> None:
+        self.close()
+
+    def close(self) -> None:
+        # returns None on purpose: awaiting dismiss() from a handler is an error
+        if self.app.screen is self:
+            self.dismiss()