notesmgr 0.1.0__py3-none-any.whl

notesmgr/__init__.py

@@ -0,0 +1,5 @@
+#! /usr/local/bin/python3
+"""The notesmgr package."""
+
+# Copyright (c) 2026 Tom Björkholm
+# MIT License

notesmgr/__main__.py

@@ -0,0 +1,10 @@
+#! /usr/local/bin/python3
+"""Entry point for running notesmgr as `python3 -m notesmgr`."""
+
+# Copyright (c) 2026 Tom Björkholm
+# MIT License
+
+from notesmgr.application import main
+
+if __name__ == '__main__':  # pragma: no cover
+    main()

notesmgr/actions.py

@@ -0,0 +1,86 @@
+#! /usr/local/bin/python3
+"""What can be done with what is selected, and when it can be done."""
+
+# Copyright (c) 2026 Tom Björkholm
+# MIT License
+
+from typing import NamedTuple
+
+COPY_RAW = 'Copy raw'
+"""What the action that copies the note as it is written is called."""
+
+COPY_FORMATTED = 'Copy formatted'
+"""What the action that copies the note formatted is called."""
+
+DUPLICATE = 'Duplicate'
+"""What the action that copies the note into the project is called."""
+
+EDIT = 'Edit'
+"""What the action that opens the note in an editor is called."""
+
+NEW = 'New'
+"""What the action that makes another note is called."""
+
+DELETE = 'Delete'
+"""What the action that takes the note away is called."""
+
+MOVE_UP = 'Up'
+"""What the action that moves the note one place up is called."""
+
+MOVE_DOWN = 'Down'
+"""What the action that moves the note one place down is called."""
+
+NEW_FOLDER = 'New folder…'
+"""What the action that makes another folder is called."""
+
+RENAME_FOLDER = 'Rename folder…'
+"""What the action that gives a folder another name is called."""
+
+DELETE_FOLDER = 'Delete folder'
+"""What the action that takes an empty folder away is called."""
+
+ON_NOTE = (COPY_RAW, COPY_FORMATTED, EDIT)
+"""What can be done with any note that is shown, template or not."""
+
+ON_PLAIN = (DUPLICATE, DELETE, MOVE_UP, MOVE_DOWN)
+"""What can be done with a note that is no template of a folder."""
+
+ON_PROJECT = (NEW, NEW_FOLDER)
+"""What can be done as long as there is a project to do it in."""
+
+ON_FOLDER = (RENAME_FOLDER, DELETE_FOLDER)
+"""What can be done with a folder that is no root of a project."""
+
+
+class Selected(NamedTuple):
+    """What is selected, as far as it says what can be done with it.
+
+    The panel knows whether there is a note to act on, because a note
+    can be taken away by another program while it is shown, and the
+    rest follows from the item that the explorer has selected.
+    """
+
+    note: bool = False
+    plain: bool = False
+    project: bool = False
+    folder: bool = False
+
+
+NOTHING = Selected()
+"""What is selected while nothing at all is."""
+
+
+def offered(selected: Selected) -> frozenset[str]:
+    """Return what can be done with what is selected.
+
+    Args:
+        selected: What the explorer has selected now.
+
+    Returns:
+        The actions that the buttons and the menu entries offer,
+        every other action of the application being greyed out.
+    """
+    groups = ((selected.note, ON_NOTE), (selected.plain, ON_PLAIN),
+              (selected.project, ON_PROJECT), (selected.folder, ON_FOLDER))
+    return frozenset(action for allowed, group in groups if allowed
+                     for action in group)

notesmgr/application.py

@@ -0,0 +1,93 @@
+#! /usr/local/bin/python3
+"""Start-up of the notesmgr application."""
+
+# Copyright (c) 2026 Tom Björkholm
+# MIT License
+
+import sys
+import tkinter
+from contextlib import suppress
+from functools import partial
+from pathlib import Path
+from typing import Optional
+from notesmgr.cmd_line import parse_command_line
+from notesmgr.console import console_or_window
+from notesmgr.errors import NotesmgrError
+from notesmgr.failure_report import report_failures
+from notesmgr.main_window import MainWindow
+from notesmgr.version_info import version_report
+
+NO_WINDOW = 'notesmgr cannot open a window: {error}'
+"""What is said when there is no display to show a window on."""
+
+
+def main(argv: Optional[list[str]] = None) -> None:
+    """Run the notesmgr graphical user interface until the user quits.
+
+    A command line asking for version information is answered on the
+    standard output stream, and no window is opened for it. A command
+    line naming a project folder opens that project, and says in a
+    window of its own when the folder holds no project. What the
+    command line has to say is shown in a window where there is no
+    console to say it on.
+
+    Args:
+        argv: Command line arguments, or None for the ones this
+            program was started with.
+    """
+    with console_or_window():
+        command_line = parse_command_line(argv)
+        if command_line.show_version:
+            report_versions()
+            return
+    run_window(command_line.project)
+
+
+def report_versions() -> None:
+    """Write the version report on the standard output stream.
+
+    Raises:
+        SystemExit: The report cannot be made, which is said on the
+            standard error stream in words rather than as a traceback,
+            and is said before leaving, as a command line error is, so
+            that a window can show it where there is no console.
+    """
+    try:
+        version_report(sys.stdout)
+    except NotesmgrError as error:
+        print(error, file=sys.stderr)
+        sys.exit(1)
+
+
+def new_root() -> tkinter.Tk:
+    """Return the root window, or leave saying why there can be none.
+
+    Raises:
+        SystemExit: There is no display, which a program started from
+            a terminal with no display is told in one line.
+    """
+    try:
+        return tkinter.Tk()
+    except tkinter.TclError as error:
+        sys.exit(NO_WINDOW.format(error=error))
+
+
+def open_window(root: tkinter.Tk, project: Optional[Path]) -> None:
+    """Fill the root window, and open the named project in it, if any."""
+    window = MainWindow(root)
+    if project is not None:
+        window.load_project(project)
+
+
+def run_window(project: Optional[Path]) -> None:
+    """Show the main window until the user quits.
+
+    Args:
+        project: The project to open at start, None for none at all.
+    """
+    root = new_root()
+    report_failures(root).run(partial(open_window, root, project))
+    root.mainloop()
+    # Quitting through the menu has already destroyed the root window.
+    with suppress(tkinter.TclError):
+        root.destroy()

notesmgr/button_row.py

@@ -0,0 +1,149 @@
+#! /usr/local/bin/python3
+"""The row of buttons above the note, and how it is made to fit."""
+
+# Copyright (c) 2026 Tom Björkholm
+# MIT License
+
+import tkinter
+from tkinter import ttk
+from typing import AbstractSet, Callable, NamedTuple, Optional, Sequence
+from notesmgr.menu_bar import entry_state
+
+GAP = 4
+"""Pixels left between two buttons that stand side by side."""
+
+
+class ButtonSpec(NamedTuple):
+    """One button of the row, and what pressing it does.
+
+    A button that is described with no command has nothing to do,
+    and is greyed out whatever is selected, so that a row can be
+    the whole row before every one of its buttons is wired up.
+    """
+
+    label: str
+    command: Optional[Callable[[], None]] = None
+
+
+def grid_width(widths: Sequence[int], columns: int, gap: int) -> int:
+    """Return how wide a grid of buttons of these widths is.
+
+    The buttons are placed row by row, so the buttons of one column
+    are every columns-th of them, and a column is as wide as the
+    widest button standing in it.
+
+    Args:
+        widths: How wide each button is, in the order they are shown.
+        columns: How many buttons stand side by side.
+        gap: Pixels left beside each button.
+
+    Returns:
+        The width the grid needs, and nothing for no buttons at all.
+    """
+    if columns < 1:
+        return 0
+    return sum(max(widths[column::columns]) + gap
+               for column in range(min(columns, len(widths))))
+
+
+def fitting_columns(widths: Sequence[int], available: int, gap: int) -> int:
+    """Return how many buttons to put side by side in a given width.
+
+    The buttons are spread over the fewest rows that fit, so that a
+    wide panel shows one row and a narrow one shows several rows of
+    about the same length rather than one long row and a short one.
+    A width too small for even one button still gives one column,
+    because a button cut off at the edge is better than none at all.
+
+    Args:
+        widths: How wide each button is, in the order they are shown.
+        available: Pixels the row has to lay the buttons out in.
+        gap: Pixels left beside each button.
+
+    Returns:
+        How many buttons stand side by side, at least one.
+    """
+    for rows in range(1, len(widths) + 1):
+        columns = (len(widths) + rows - 1) // rows
+        if grid_width(widths, columns, gap) <= available:
+            return columns
+    return 1
+
+
+class ButtonRow:
+    """The buttons above the note, in as few rows as the width allows.
+
+    A button is as wide as its text and the theme of the platform
+    make it, and the panel is as wide as the user makes the window,
+    so the buttons are laid out again whenever the width changes.
+    That way none of them is ever cut off at the edge of the panel,
+    at any size the window can be given.
+    """
+
+    def __init__(self, parent: tkinter.Misc,
+                 specs: Sequence[ButtonSpec]) -> None:
+        """Build the described buttons in a frame of their own.
+
+        Args:
+            parent: The widget that the row is placed in.
+            specs: The buttons, in the order they are shown.
+        """
+        self.frame = ttk.Frame(parent)
+        self.specs = list(specs)
+        self.buttons = [self._built(spec) for spec in specs]
+        self.working = {spec.label: button
+                        for spec, button in zip(specs, self.buttons)
+                        if spec.command is not None}
+        self.columns = 0
+        self.lay_out(max(len(self.buttons), 1))
+        self.frame.bind('<Configure>', self._width_changed)
+
+    def _built(self, spec: ButtonSpec) -> ttk.Button:
+        """Return one button of the row, greyed out to start with."""
+        button = ttk.Button(self.frame, text=spec.label,
+                            state=entry_state(False))
+        if spec.command is not None:
+            button.configure(command=spec.command)
+        return button
+
+    def _width_changed(self, event: 'tkinter.Event[ttk.Frame]') -> None:
+        """Lay the buttons out again when the row has another width."""
+        self.fit_into(event.width)
+
+    def widths(self) -> list[int]:
+        """Return how wide each button of the row asks to be."""
+        return [button.winfo_reqwidth() for button in self.buttons]
+
+    def fit_into(self, available: int) -> None:
+        """Lay the buttons out for a row of the given width.
+
+        Laying out a grid that is already laid out that way would
+        make Tk report another width and ask again, so it is only
+        done when another number of buttons fits now.
+
+        Args:
+            available: Pixels the row has to lay the buttons out in.
+        """
+        columns = fitting_columns(self.widths(), available, GAP)
+        if columns != self.columns:
+            self.lay_out(columns)
+
+    def lay_out(self, columns: int) -> None:
+        """Put the buttons into a grid so many buttons wide."""
+        self.columns = columns
+        for index, button in enumerate(self.buttons):
+            button.grid(row=index // columns, column=index % columns,
+                        padx=GAP // 2, pady=GAP // 2, sticky=tkinter.W)
+
+    def offer(self, labels: AbstractSet[str]) -> None:
+        """Let the buttons that can be used now be pressed.
+
+        A button that was described with no command has nothing to do
+        when pressed, and stays greyed out however much the selection
+        would allow it.
+
+        Args:
+            labels: What the buttons that can be used now say.
+        """
+        for label, button in self.working.items():
+            button.configure(state=entry_state(label in labels))

notesmgr/clipboard_linux.py

@@ -0,0 +1,58 @@
+#! /usr/local/bin/python3
+"""Putting a formatted copy of a note on the clipboard of a desktop."""
+
+# Copyright (c) 2026 Tom Björkholm
+# MIT License
+
+import shutil
+from typing import Optional, Sequence
+from notesmgr.clipboard_tool import RichText, run_tool
+from notesmgr.errors import NotesmgrError
+
+XCLIP = ('xclip', '-selection', 'clipboard', '-t', 'text/html')
+"""What puts HTML on the clipboard of an X11 desktop."""
+
+WL_COPY = ('wl-copy', '-t', 'text/html')
+"""What puts HTML on the clipboard of a Wayland desktop."""
+
+TOOLS = (XCLIP, WL_COPY)
+"""The programs that can take a formatted copy, the first one first.
+
+A Wayland desktop usually answers for X11 programs as well, so the
+one that works on both is the one that is tried first.
+"""
+
+NO_TOOL = 'Neither xclip nor wl-copy is installed, and one of them is ' \
+    'what puts formatted text on the clipboard of this desktop.'
+"""What is said when the desktop has neither of the two programs."""
+
+CHARSET = '<meta charset="utf-8">'
+"""What says that the HTML of a copy is written as UTF-8."""
+
+
+def html_tool() -> Optional[Sequence[str]]:
+    """Return the program that takes a formatted copy, None for none."""
+    return next((tool for tool in TOOLS
+                 if shutil.which(tool[0]) is not None), None)
+
+
+def copy_to_clipboard(payload: RichText) -> None:
+    """Put a formatted copy of a note on the clipboard of a desktop.
+
+    The clipboard of X11 and of Wayland is owned by a program rather
+    than held by the system, and the program that owns it offers the
+    one shape it was given, so the formatted shape is what is put
+    there. That program goes on running to answer for the clipboard,
+    and is therefore not waited for.
+
+    Args:
+        payload: The copy to put there.
+
+    Raises:
+        NotesmgrError: The desktop has no program that takes a
+            formatted copy, or the one it has refused this copy.
+    """
+    tool = html_tool()
+    if tool is None:
+        raise NotesmgrError(NO_TOOL)
+    run_tool(tool, (CHARSET + payload.html).encode('utf-8'), capture=False)

notesmgr/clipboard_macos.py

@@ -0,0 +1,78 @@
+#! /usr/local/bin/python3
+"""Putting a formatted copy of a note on the pasteboard of macOS."""
+
+# Copyright (c) 2026 Tom Björkholm
+# MIT License
+
+from pathlib import Path
+from tempfile import TemporaryDirectory
+from notesmgr.clipboard_tool import RichText, run_tool
+
+TEXTUTIL = ('textutil', '-stdin', '-format', 'html', '-inputencoding',
+            'UTF-8', '-convert', 'rtf', '-stdout')
+"""What turns the HTML of a note into the rich text that macOS pastes.
+
+It is part of macOS itself, so a formatted copy costs notesmgr no
+dependency of its own.
+"""
+
+SCRIPT = """on run argv
+set rtf_path to POSIX file (item 1 of argv)
+set txt_path to POSIX file (item 2 of argv)
+set rtf_data to read rtf_path as «class RTF »
+set plain_text to read txt_path as «class utf8»
+set the clipboard to {«class RTF »:rtf_data, string:plain_text}
+end run"""
+"""What puts both shapes of a copy on the pasteboard in one write.
+
+A second write would replace the first, so the rich text and the
+plain text are given to the pasteboard together. They are read from
+files rather than written into the script itself, because a note is
+longer than a command line may be.
+
+The names here are of two words each because AppleScript knows a
+great many words of one: a variable called plain, for one, is a
+term of the language already, and setting it is refused.
+"""
+
+OSASCRIPT = ('osascript', '-e', SCRIPT)
+"""What runs that script, with the two files as its arguments."""
+
+RTF_NAME = 'note.rtf'
+"""What the file holding the rich text of a copy is called."""
+
+TEXT_NAME = 'note.txt'
+"""What the file holding the plain text of a copy is called."""
+
+
+def written(folder: Path, name: str, data: bytes) -> str:
+    """Write one shape of a copy into a folder, and name the file.
+
+    Args:
+        folder: The folder that the file is written into.
+        name: What the file is to be called.
+        data: What the file is to hold.
+
+    Returns:
+        The file, named as the script that reads it names it.
+    """
+    path = folder / name
+    path.write_bytes(data)
+    return str(path)
+
+
+def copy_to_clipboard(payload: RichText) -> None:
+    """Put a formatted copy of a note on the pasteboard of macOS.
+
+    Args:
+        payload: The copy to put there.
+
+    Raises:
+        NotesmgrError: macOS did not take the copy.
+    """
+    rich = run_tool(TEXTUTIL, payload.html.encode('utf-8'))
+    with TemporaryDirectory() as made:
+        folder = Path(made)
+        argv = (*OSASCRIPT, written(folder, RTF_NAME, rich),
+                written(folder, TEXT_NAME, payload.text.encode('utf-8')))
+        run_tool(argv, b'')

notesmgr/clipboard_tool.py

@@ -0,0 +1,84 @@
+#! /usr/local/bin/python3
+"""What a formatted copy of a note is, and running what takes it.
+
+The clipboard of Tk carries plain text and nothing else, so a copy
+that keeps its formatting is handed to a program of the system
+instead. Running such a program and saying what it could not do is
+the same on every platform, and is therefore done here.
+"""
+
+# Copyright (c) 2026 Tom Björkholm
+# MIT License
+
+import subprocess
+from typing import NamedTuple, Optional, Sequence
+from notesmgr.errors import NotesmgrError
+
+NOT_INSTALLED = 'The program {program} is not installed, and it is what ' \
+    'puts a formatted copy on the clipboard here.'
+"""What is said when the system has not got the program it needs."""
+
+REFUSED = 'The program {program} did not take a formatted copy of the ' \
+    'note.\n{reason}'
+"""What is said when the program was there but did not do it."""
+
+
+class RichText(NamedTuple):
+    """A copy of a note in the shapes that a clipboard takes it in.
+
+    The HTML is what goes inside the body of a document rather than
+    a whole document, so that each platform can wrap it the way its
+    own clipboard asks for. The text is the note as it is written,
+    which is what a plain text field is pasted with.
+    """
+
+    html: str
+    text: str
+
+
+def said_by(output: Optional[bytes]) -> str:
+    """Return what a program wrote about itself, as text.
+
+    Args:
+        output: What the program wrote on its error output, None
+            when nothing was read from it.
+
+    Returns:
+        What it said, and nothing at all when it said nothing.
+    """
+    return '' if not output else output.decode('utf-8', 'replace').strip()
+
+
+def run_tool(argv: Sequence[str], data: bytes, capture: bool = True) -> bytes:
+    """Run a program of the system, and return what it wrote.
+
+    Args:
+        argv: The program to run and the arguments to give it.
+        data: What is written to the program on its input.
+        capture: Whether to read what the program writes. A program
+            that goes on running to own the clipboard, as the ones
+            of the X11 and the Wayland desktops do, never closes its
+            output, and waiting for that output to end would be
+            waiting for the program to end.
+
+    Returns:
+        What the program wrote, and nothing when it is not read.
+
+    Raises:
+        NotesmgrError: The program is not installed, could not be
+            started, or refused to do it.
+    """
+    where = subprocess.PIPE if capture else subprocess.DEVNULL
+    try:
+        done = subprocess.run(argv, input=data, stdout=where, stderr=where,
+                              check=True)
+    except FileNotFoundError as error:
+        raise NotesmgrError(NOT_INSTALLED.format(program=argv[0])) from error
+    except subprocess.CalledProcessError as error:
+        reason = said_by(error.stderr) or str(error)
+        raise NotesmgrError(REFUSED.format(program=argv[0],
+                                           reason=reason)) from error
+    except OSError as error:
+        raise NotesmgrError(REFUSED.format(program=argv[0],
+                                           reason=error)) from error
+    return done.stdout or b''