nervous-notes 0.0.1__py3-none-any.whl

nervous_notes/__init__.py

@@ -0,0 +1,10 @@
+from .wrappers.external_messages import get_config_from_env
+from .nervous_note import NervousNote
+from .note_embedded_script import NoteEmbeddedScript
+from .nervous_process import NervousProcess
+from multiprocessing.connection import Connection
+from . import dsl
+__all__ = [
+    "NervousNote", "NoteEmbeddedScript", "NervousProcess", "get_config_from_env", "dsl",
+    "Connection",  # for typing
+]

nervous_notes/__main__.py

@@ -0,0 +1,44 @@
+import logging
+import argparse
+
+from .orchestration import Orchestrator
+from .nervous_note import NervousNote
+from .wrappers.external_messages import get_config_from_env
+
+
+logging.basicConfig(level=logging.INFO,
+                    format='[%(asctime)s %(pathname)s:%(lineno)s] - %(message)s',
+                    datefmt='%Y-%m-%d %H:%M:%S')
+
+parser = argparse.ArgumentParser()
+parser.add_argument("vault_path", help="Path to the vault directory", type=str)
+
+# FIXME: need to make sure this is properly optional, in the Orchestrator
+parser.add_argument("--scripts", help="The directory for scripts")
+
+args = parser.parse_args()
+
+mqtt_config = get_config_from_env()
+if mqtt_config:
+    logging.info(f"Using vault {args.vault_path}, mqtt broker {mqtt_config.broker}:{mqtt_config.port} for user {mqtt_config.username}, and scripts_dir {args.scripts}")
+else:
+    logging.info(f"Failed to get mqtt config, proceeding with None config...")
+
+NervousNote.start_background_actors(args.vault_path, mqtt_config)
+# FIXME: can I delete the password to let it get garbage collected?
+
+deploy_debug_notes = False
+# pykka.DeadLetterRouter.default_router().start() #?
+orchestrator = Orchestrator.wake("Nervous Notes Orchestrator", args.scripts, deploy_debug_notes)
+
+try:
+    while True:
+        input()
+except KeyboardInterrupt:
+    logging.info("KeyboardInterrupt detected, stopping...")
+    orchestrator.stop()
+    logging.info("Orchestrator stopped")
+    NervousNote.stop_background_actors()
+
+    # FIXME: what more is needed for a proper, clean shutdown?
+    # exit(0)

nervous_notes/dsl.py

@@ -0,0 +1,63 @@
+"""
+used for typing, not at runtime
+
+runtime comes from scriping.CompiledScript.script_scope
+"""
+
+import logging
+import json
+import datetime
+from time import ctime, sleep
+
+import requests
+from pykka import ActorRef
+
+from .note_companion_script import TemplateScript
+from .util import TimeUtil, Clock
+
+from .nervous_note import MqttWrapper
+from .wrappers.note_api import datetimestamped_markdown_list_line, timestamped_markdown_list_line, NoteAPI
+
+
+my_note: NoteAPI
+note_name: str
+topic: str
+default_topic: str
+mqtt: MqttWrapper
+
+_clock = Clock()
+_timeutils = TimeUtil(_clock)
+next_occurrence = _timeutils.next_occurrence
+seconds_until = _timeutils.seconds_until
+today = _clock.today
+
+
+# may be expanded beyond template scripts
+def wake(notename: str, template_script_name: TemplateScript) -> ActorRef: pass
+
+
+def set_timer(delay_seconds: float | int, payload: bytes | None = None, key: str | None = None) -> None: pass
+
+
+def cancel_timer(key: str) -> None: pass
+
+
+def subscribe_internal(topic: str, subscriber) -> None: pass
+
+
+def publish_internal(topic: str, payload: bytes) -> None: pass
+
+
+def on_mqtt_message(topic: str, payload: bytes) -> None: pass
+
+
+def on_note_modified() -> None: pass
+
+
+def on_start() -> None: pass
+
+
+def on_timer(key: str, payload: object) -> None: pass
+
+
+def publish_to_ntfy(channel: str, message: str) -> None: pass

nervous_notes/example_scripts/Example - Daily Responsibility.py

@@ -0,0 +1,75 @@
+if TYPE_CHECKING:  # IDE support
+    from ..dsl import *
+
+
+def on_start():
+    reset_timer_from_note()  # THERE's ALWAYS _a_ TIMER, for later today or tomorrow
+
+
+def on_note_modified():
+    note = my_note.note_if_markdown_starts_with_pressed_button()
+    if note:
+        _frontmatter, markdown = note
+        sleep(0.25)
+        if today().isoformat() not in markdown:
+            updated_markdown = markdown_list_prepender(markdown)
+            reset_timer_from_note(note)
+            my_note.set_markdown(updated_markdown)
+        else:
+            my_note.reset_button_at_start_of_markdown()
+
+
+def on_timer(_key, _payload):
+    note = frontmatter, _markdown = my_note.get_note()
+    channel = frontmatter.get("channel")
+    message = frontmatter.get("message")
+    logging.info(f"Timer called, publishing to {channel}: {message}")
+    publish_to_ntfy(channel, message)
+    reset_timer_from_note(note)
+
+
+# utils
+
+def markdown_list_prepender(markdown: str) -> str:
+    """
+    - reset the button
+    - prepend today's date (after the button)
+    """
+    lines = markdown.splitlines()
+    lines[0] = "- [ ] Mark as done"
+    line_to_prepend = f"- [[{my_note.note_name} ({today().isoformat()})]]"
+    lines.insert(1, line_to_prepend)
+    lines[-1] = lines[-1] + "\n"
+    return "\n".join(lines)
+
+
+def reset_timer_from_note(note=None):
+    """
+    resets the timer for later today or tomorrow
+    """
+    if note is None:
+        note = my_note.get_note()
+
+    if note is not None:
+        frontmatter, markdown = note
+
+        next_notification = next_occurrence(frontmatter.get("ifNotDoneBy"))
+        rightnows_today = today()
+
+        today_marked_as_done = rightnows_today.isoformat() in markdown
+        next_notification_is_for_today = ((rightnows_today.year, rightnows_today.month, rightnows_today.day) ==
+                                          (next_notification.year, next_notification.month, next_notification.day))
+
+        next_notification_already_done = today_marked_as_done and next_notification_is_for_today
+        if next_notification_already_done:
+            next_notification += datetime.timedelta(days=1)
+
+        delay = seconds_until(next_notification)
+        logging.info(f"Setting timer for {next_notification}, delay {delay}s")
+        set_timer(
+            delay,
+            None,  # no payload for this timer
+            key=f"{my_note.note_name}/TIMER"  # there's just one timer
+        )
+    else:
+        logging.warning("No note; need yaml for {channel, message, ifNotDoneBy} (e.g. ifNotDoneBy = 20:32:00-07:00)")

nervous_notes/example_scripts/Example - Extrovert.py

@@ -0,0 +1,34 @@
+def on_start():
+    my_note.set_file_contents(f"""---
+in_topic: {default_topic}
+out_topic: {default_topic}/publish
+message_to_send: "Hello :)"
+---
+- [ ] Send message
+- Instructions:
+    - `out_topic` is updated live, but `in_topic` is currently provided but not read back
+- ---
+""")
+
+def on_mqtt_message(topic, message):
+    my_note.append_datetimestamped_markdown_list_line(f"Received on {topic} message: {message.decode()}")
+
+def on_note_modified():
+    if (maybe_note := my_note.note_if_markdown_starts_with_pressed_button()) is not None:
+        frontmatter, markdown = maybe_note
+    else:
+        return # not a note update we care about
+
+    if (out_topic := frontmatter.get("out_topic")) is None:
+        logging.warning("Button pressed but Frontmatter out_topic was empty")
+        return
+
+    if (message_to_send := frontmatter.get("message_to_send")) is None:
+        logging.warning("Button pressed but Frontmatter message_to_send was empty")
+        return
+
+    # introvert expects `(sender)> (message)` where sender is who they will reply to
+    mqtt.publish(out_topic, f"{topic}> {message_to_send}")
+
+    sleep(.25) # hack so Obsidian sees the update (otherwise it seems to miss it sometimes)
+    my_note.reset_button_at_start_of_markdown()

nervous_notes/example_scripts/Example - Introvert.py

@@ -0,0 +1,54 @@
+def on_start():
+    my_note.set_file_contents(f"""---
+in_topic: {default_topic}
+reply_with: "👋"
+---
+- [ ] Pause replying
+- Instructions:
+    - Change `reply_with` to whatever you would like (`in_topic` does not read back updates currently)
+    - delay_seconds is an optional field, assumed to be 0 (seconds)
+- ---
+""")
+
+sending = True
+
+def on_mqtt_message(topic, message):
+    config = my_note.get_frontmatter()
+
+    try:
+        # expects:
+        # sending_topic> message
+        sender, what_they_sent = message.decode().split(">", 1)
+    except ValueError:
+        my_note.append_datetimestamped_markdown_list_line(f"Received a weirdly formatted message: {message}")
+        return
+
+    if not sending:
+        my_note.append_datetimestamped_markdown_list_line(f"{sender} sent {what_they_sent}, not replying (sending paused)")
+        return
+
+    delay_seconds = config.get("delay_seconds", 0)
+
+    if (reply_with := config.get("reply_with")) is not None:
+        if delay_seconds:
+            set_timer(delay_seconds, (sender, reply_with))
+            my_note.append_datetimestamped_markdown_list_line(f"Received {what_they_sent}, replying with {reply_with} after {delay_seconds}s")
+        else:
+            my_note.append_datetimestamped_markdown_list_line(f"Received {what_they_sent}, replying with {reply_with}")
+            mqtt.publish(sender, reply_with)
+    else:
+        my_note.append_datetimestamped_markdown_list_line(f"{sender} sent {what_they_sent}, not replying (no reply_with frontmatter)")
+
+def on_timer(key, payload):
+    sender, reply_with = payload
+    mqtt.publish(sender, reply_with)
+
+
+def on_note_modified():
+    global sending  # nonlocal doesn't work because sending is not enclosed in a function
+
+    maybe_note = my_note.note_if_markdown_starts_with_pressed_button()
+    if maybe_note is not None:
+        sending = False
+    else:
+        sending = True

nervous_notes/example_scripts/Example - Recurring Note Generator.py

@@ -0,0 +1,61 @@
+from datetime import timedelta
+from typing import io
+
+if TYPE_CHECKING:  # IDE support
+    from dsl import *
+
+
+class Frontmatter:
+    pass
+
+
+class Document:
+    frontmatter: Frontmatter
+    markdown: str
+
+
+def on_start():
+    note = my_note.get_note()
+    if note is not None:
+        frontmatter, markdown = note
+
+        next_date = frontmatter.get("next_date")
+        default_interval_days = frontmatter.get("default_interval_days")
+
+        _button, current_next_note, *history = markdown.splitlines()
+
+        if current_next_note[:8] != "- Next: " or not current_next_note.endswith(")]]"):
+            logging.warning(f"Expected second line to start with `- Next: ` then a wikilink of the format [[Note (YYYY-MM-DD)]]")
+            return
+
+        current_next_date = current_next_note[-13:-3]
+        if next_date is None:
+            next_date = datetime.datetime.strptime(current_next_date, "%Y-%m-%d") + timedelta(days=default_interval_days)
+
+
+def on_note_modified():
+    note = my_note.note_if_markdown_starts_with_pressed_button()
+    if note:
+        frontmatter, markdown = note
+        # FIXME
+        stream = io.StringIO()
+        my_note.yaml.dump(data, stream)
+
+        # Extract the YAML string
+        yaml_string = stream.getvalue()
+
+
+# utils
+
+# FIXME: factor out?
+def markdown_list_prepender(markdown: str) -> str:
+    """
+    - reset the button
+    - prepend today's date (after the button)
+    """
+    lines = markdown.splitlines()
+    lines[0] = "- [ ] Mark as done"
+    line_to_prepend = f"- [[{my_note.note_name} ({datetime.date.today().isoformat()})]]"
+    lines.insert(1, line_to_prepend)
+    lines[-1] = lines[-1] + "\n"
+    return "\n".join(lines)

nervous_notes/example_scripts/Literate Programming - Hello World.py

@@ -0,0 +1,53 @@
+def on_start():
+    my_note.set_file_contents(f"""---
+in_topic: {default_topic}
+out_topic: {default_topic}/publish
+message_to_send: "Hello :)"
+---
+- [ ] Send message
+- Instructions:
+    - press the button above to send `message_to_send` to `out_topic`
+    - (this can be observed via mosquitto_pub)
+    - send a message to `in_topic` and observe it listed below
+    - `out_topic` is read dynamically but `in_topic` is provided for informational purposes only
+- ---
+""")
+
+
+def on_mqtt_message(topic, message):
+    my_note.append_datetimestamped_markdown_list_line(f"received on `{topic}`: {message}")
+
+
+def on_note_modified():
+    if (maybe_note := my_note.note_if_markdown_starts_with_pressed_button()) is not None:
+        frontmatter, markdown = maybe_note
+    else:
+        logging.debug("Note modified but button not pressed")
+        return
+    
+    if (out_topic := frontmatter.get("out_topic")) is None:
+        logging.warning("Button pressed but Frontmatter out_topic was empty")
+        return
+
+    if (message_to_send := frontmatter.get("message_to_send")) is None:
+        logging.warning("Button pressed but Frontmatter message_to_send was empty")
+        return
+
+    logging.info(f"[{note_name}] publishing {message_to_send} to mqtt")
+    mqtt.publish(out_topic, message_to_send)
+
+    logging.info(f"[{note_name}] resetting markdown...")
+
+    sleep(.25) # hack to prevent a race condition with Obsidian's display
+    my_note.upsert_markdown(lambda markdown: upserter(out_topic, message_to_send, markdown))
+    logging.info(f"[{note_name}] Markdown reset")
+
+
+# util
+
+def upserter(out_topic, message_to_send, markdown):
+    lines = markdown.splitlines()
+    lines[0] = f"- [ ] Send (last sent ~{ctime()})"
+    lines.append(timestamped_markdown_list_line(f"sending on `{out_topic}`: {message_to_send}"))
+
+    return "\n".join(lines)

nervous_notes/example_scripts/Mqtt Publisher.py

@@ -0,0 +1,30 @@
+def on_start():
+    my_note.set_file_contents(f"""---
+out_topic: "(fill in)"
+message_to_send: "hello"
+---
+- [ ] Send
+""")
+
+def on_mqtt_message(topic, message):
+    my_note.append_datetimestamped_markdown_list_line(f"(ignoring) received on `{topic}`: {message}")
+
+
+def on_note_modified():
+    if (maybe_note := my_note.note_if_markdown_starts_with_pressed_button()) is not None:
+        frontmatter, markdown = maybe_note
+    else:
+        return # not a note update we care about
+
+    if (out_topic := frontmatter.get("out_topic")) is None:
+        logging.warning("Button pressed but Frontmatter out_topic was empty")
+        return
+
+    if (message_to_send := frontmatter.get("message_to_send")) is None:
+        logging.warning("Button pressed but Frontmatter message_to_send was empty")
+        return
+
+    mqtt.publish(out_topic, message_to_send)
+
+    sleep(.25) # hack so Obsidian sees the update (otherwise it seems to miss it sometimes)
+    my_note.reset_button_at_start_of_markdown()

nervous_notes/example_scripts/Mqtt Subscriber.py

@@ -0,0 +1,8 @@
+def on_start():
+    my_note.set_file_contents(f"""---
+in_topic: "{topic}"
+---
+""")
+
+def on_mqtt_message(topic, message):
+    my_note.append_datetimestamped_markdown_list_line(f"received on `{topic}`: {message}")

nervous_notes/example_scripts/Next Notes Manager.py

@@ -0,0 +1,25 @@
+if TYPE_CHECKING:  # IDE support
+    from ..dsl import *
+
+
+def on_start():
+    frontmatter, markdown = my_note.get_note()
+
+    lines = markdown.strip().split('\n')
+
+    failed_matches = []
+    for line in lines:
+        if not line.startswith('- [[') or not line.endswith(']]'):
+            failed_matches.append(line)
+
+    if failed_matches:
+        logging.warning(f"Failed matches! {failed_matches} (lines: {lines})")
+        return
+
+    template_to_use = frontmatter.get("template_to_use", "Next-Notes MOC")
+    logging.info(f"Using template: {template_to_use}")
+
+    next_notes = [line[4:-2] for line in lines]
+    for next_note in next_notes:
+        logging.info(f"waking [[{next_note}]]")
+        wake(next_note, TemplateScript(template_to_use))

nervous_notes/example_scripts/Next-Notes MOC.py

@@ -0,0 +1,91 @@
+from datetime import timedelta
+
+if TYPE_CHECKING:  # IDE support
+    from ..dsl import *
+
+DEFAULT_INTERVAL_DAYS = 7
+
+
+def on_start():
+    if my_note.already_exists():
+        return
+
+    today_today = today()
+    my_note.set_file_contents(f"""---
+default_interval_days: {DEFAULT_INTERVAL_DAYS}
+---
+- [ ] Create next: [[{my_note.note_name} ({today_today.isoformat()})]]
+
+## History
+
+- [[{my_note.note_name} ({(today_today + timedelta(days=-DEFAULT_INTERVAL_DAYS)).isoformat()})]]
+- [[{my_note.note_name} ({(today_today + timedelta(days=-DEFAULT_INTERVAL_DAYS*2)).isoformat()})]]
+- (anything from the line above downward is basically ignored)
+- (once you create one real link, e.g. with the button, you can delete these extra lines with no problem)
+""")
+
+
+def on_note_modified():
+    logging.info("[Next-Notes Moc.py:on_note_modified] CANARY")
+    note = my_note.note_if_markdown_starts_with_pressed_button()
+    if note:
+        frontmatter, markdown = note
+
+        logging.info("Button pressed! ...")
+
+        lines = markdown.split("\n")
+        button = lines[0]
+
+        # The next note to create is named by the wikilink in the button line,
+        # e.g. "- [x] Create next: [[Next Notes Mockup (2026-07-19)]]".
+        next_target = _wikilink_target(button)
+
+        logging.warning(
+            f"The user needs to manually create: a calendar event(?) and [[{next_target}]]. Any Next* aliasing has also been left untouched."
+        )
+        # FIXME: here I can wake() the next target, if only to move the alias along... how to model that?
+
+        # Advance the button to the note after this one, keeping the label text.
+        interval_days = frontmatter.get("default_interval_days", 7)
+        following_target = _bump_target(next_target, interval_days)
+        label = button[len("- [x] "):button.index("[[")]
+        lines[0] = f"- [ ] {label}[[{following_target}]]"
+
+        # Record the just-created note at the top of History, if not already there.
+        history_line = f"- [[{next_target}]]"
+        if history_line not in lines:
+            sleep(0.25)
+            _prepend_to_history(lines, history_line)
+
+        my_note.set_markdown("\n".join(lines))
+        logging.info("Done, setting markdown...")
+
+
+# utils
+
+
+def _wikilink_target(text: str) -> str:
+    """Return the NAME inside the first [[NAME]] wikilink in `text`."""
+    start = text.index("[[") + 2
+    end = text.index("]]", start)
+    return text[start:end]
+
+
+def _bump_target(target: str, interval_days: int) -> str:
+    """"Base (YYYY-MM-DD)" -> same base with the date advanced `interval_days`."""
+    base = target[:target.rindex(" (")]
+    date_str = target[target.rindex("(") + 1:target.rindex(")")]
+    date = datetime.datetime.strptime(date_str, "%Y-%m-%d").date()
+    following = date + datetime.timedelta(days=interval_days)
+    return f"{base} ({following.isoformat()})"
+
+
+def _prepend_to_history(lines: list, history_line: str) -> None:
+    """Insert `history_line` before the first existing History entry (or append)."""
+    header_index = lines.index("## History")
+    insert_at = len(lines)
+    for i in range(header_index + 1, len(lines)):
+        if lines[i].startswith("- [["):
+            insert_at = i
+            break
+    lines.insert(insert_at, history_line)

nervous_notes/example_scripts/Timer Demo.py

@@ -0,0 +1,31 @@
+def on_start():
+    my_note.set_file_contents(f"""---
+duration_seconds: 1
+---
+- [ ] Start timer
+""")
+
+
+def on_note_modified():
+    if (maybe_note := my_note.note_if_markdown_starts_with_pressed_button()) is not None:
+        frontmatter, markdown = maybe_note
+    else:
+        return # not a note update we care about
+
+    if (duration_seconds := frontmatter.get("duration_seconds")) is None:
+        logging.warning("Button pressed but Frontmatter duration_seconds was empty")
+        return
+    
+    set_timer(duration_seconds, duration_seconds)
+    sleep(.25) # hack so Obsidian sees the update (otherwise it seems to miss it sometimes)
+    my_note.upsert_markdown(lambda markdown: upserter(duration_seconds, markdown))
+
+def on_timer(key, duration_seconds):
+    my_note.append_datetimestamped_markdown_list_line(f"Finished {duration_seconds}s timer")
+
+def upserter(duration_seconds, markdown):
+    lines = markdown.splitlines()
+    lines[0] = f"- [ ] Start timer"
+    lines.append(f"- \\[{ctime()}] Just set a timer for {duration_seconds}s\n")
+
+    return "\n".join(lines)