nervous-notes 0.0.2__tar.gz → 0.0.3__tar.gz

{nervous_notes-0.0.2 → nervous_notes-0.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: nervous-notes
-Version: 0.0.2
+Version: 0.0.3
 Summary: Personal knowledge management meets the actor model
 Project-URL: Homepage, https://github.com/micseydel/nervous_notes
 Project-URL: Issues, https://github.com/micseydel/nervous_notes/issues
@@ -53,6 +53,16 @@ this_is: yaml
 
 FIXME `--library`
 
+
+### Companion scripts and the DSL
+
+- on_start
+- on_note_modified
+- on_mqtt_message
+- on_timer
+- on_message (or is it on_other_message? different from on_receive)
+- on_stop
+
 ## Glossary
 
 - FIXME
@@ -73,10 +83,6 @@ FIXME `--library`
 
 - FIXME (placeholder)
 
-## Polyglot programming
-
-This module currently includes mqtt support, which allows for sending messages between programs in different languages.
-
 ## Knowledge Based Programming
 
 Again, from the actor model paper:
@@ -103,8 +109,10 @@ I originally implemented this in Scala, where I called it "[woke notes](https://
 
 ## Future work
 
+- remove all FIXMEs from the code
 - remove mqtt as a default dependency, and make it, kafka, and rabbitmq [optional dependencies](https://setuptools.pypa.io/en/latest/userguide/dependency_management.html#optional-dependencies)
   - maybe a "whisper" optional dependency for AI transcription (since this was one of my primary use-cases)
+  - ntfy doesn't need to be core either, so `requests` could similarly be made an optional dependency
 - similar modules for other languages/platforms (e.g. JVM, Javascript, Go, etc.) to improve polyglot support
 - is Obsidian Canvas rich enough to wire actors together into flows?
 - improved isolation between companion notes
@@ -112,3 +120,8 @@ I originally implemented this in Scala, where I called it "[woke notes](https://
 - replace Pykka with something more Akka-like
   - this would likely be an _enormous_ undertaking
 - support actor-scoped `--library` imports, so that hot-reloading of imports can work
+- Change .wake() class method design
+  - Don't bother trying for a uniform interface with pykka anymore
+  - ...because wake()ing is idempotent, has a different semantic
+  - Jumping to the wake() implementation is confusing
+  - Composition instead of inheritance?

{nervous_notes-0.0.2 → nervous_notes-0.0.3}/README.md

@@ -32,6 +32,16 @@ this_is: yaml
 
 FIXME `--library`
 
+
+### Companion scripts and the DSL
+
+- on_start
+- on_note_modified
+- on_mqtt_message
+- on_timer
+- on_message (or is it on_other_message? different from on_receive)
+- on_stop
+
 ## Glossary
 
 - FIXME
@@ -52,10 +62,6 @@ FIXME `--library`
 
 - FIXME (placeholder)
 
-## Polyglot programming
-
-This module currently includes mqtt support, which allows for sending messages between programs in different languages.
-
 ## Knowledge Based Programming
 
 Again, from the actor model paper:
@@ -82,8 +88,10 @@ I originally implemented this in Scala, where I called it "[woke notes](https://
 
 ## Future work
 
+- remove all FIXMEs from the code
 - remove mqtt as a default dependency, and make it, kafka, and rabbitmq [optional dependencies](https://setuptools.pypa.io/en/latest/userguide/dependency_management.html#optional-dependencies)
   - maybe a "whisper" optional dependency for AI transcription (since this was one of my primary use-cases)
+  - ntfy doesn't need to be core either, so `requests` could similarly be made an optional dependency
 - similar modules for other languages/platforms (e.g. JVM, Javascript, Go, etc.) to improve polyglot support
 - is Obsidian Canvas rich enough to wire actors together into flows?
 - improved isolation between companion notes
@@ -91,3 +99,8 @@ I originally implemented this in Scala, where I called it "[woke notes](https://
 - replace Pykka with something more Akka-like
   - this would likely be an _enormous_ undertaking
 - support actor-scoped `--library` imports, so that hot-reloading of imports can work
+- Change .wake() class method design
+  - Don't bother trying for a uniform interface with pykka anymore
+  - ...because wake()ing is idempotent, has a different semantic
+  - Jumping to the wake() implementation is confusing
+  - Composition instead of inheritance?

{nervous_notes-0.0.2 → nervous_notes-0.0.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "nervous-notes"
-version = "0.0.2"
+version = "0.0.3"
 authors = [
   { name="Michael Seydel", email="contact@micseydel.me" },
 ]
@@ -20,8 +20,9 @@ license-files = ["LICEN[CS]E*"]
 dependencies = [
 	"pykka==4.4.2",
 	"ruamel.yaml==0.19.1",
-	"paho-mqtt==2.1.0",
 	"watchdog==6.0.0",
+	# FIXME: make these optional
+	"paho-mqtt==2.1.0",
 	"requests==2.34.2",
 ]
 

{nervous_notes-0.0.2 → nervous_notes-0.0.3}/src/nervous_notes/dsl.py

@@ -9,6 +9,7 @@ import json
 import datetime
 import re
 from time import ctime, sleep
+from typing import Any
 
 import requests
 from pykka import ActorRef
@@ -62,3 +63,7 @@ def on_timer(key: str, payload: object) -> None: pass
 
 
 def publish_to_ntfy(channel: str, message: str) -> None: pass
+
+
+def batch_publish_to_nervous_note(note_id: str, messages: list[Any]) -> None:
+    pass

{nervous_notes-0.0.2 → nervous_notes-0.0.3}/src/nervous_notes/example_scripts/Next-Notes MOC.py

@@ -26,7 +26,6 @@ default_interval_days: {DEFAULT_INTERVAL_DAYS}
 
 
 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

{nervous_notes-0.0.2 → nervous_notes-0.0.3}/src/nervous_notes/nervous_note.py

@@ -1,12 +1,13 @@
-import logging
 import os
+import logging
+import threading
 from typing import TypeVar, Any, ClassVar
 
 import pykka
 from pykka import Actor, ActorRef
 from watchdog.events import FileModifiedEvent, FileCreatedEvent
 
-from .vault_router import VaultRouter
+from .nervous_note_router import NervousNoteRouter, MessageBatch, NervousNoteSubscription
 from .wrappers.note_api import NoteAPI, PrimitiveNoteAPI
 from .wrappers.external_messages import MqttPublish, MqttSubscription, MqttConfig, ExternalMessages
 from .wrappers.file_watcher import VaultWatcher, VaultNoteSubscription
@@ -32,7 +33,10 @@ class NervousNoteSupport:
     vault_name: str = None
     file_path = None
     external_messages_actor_ref = None
-    vault_router = None
+    nervous_note_router = None
+
+    actor_cache: dict[str, ActorRef] = {}
+    lock = threading.Lock()
 
     def __init__(self, vault_path: str, mqtt_config: MqttConfig):
         self.vault_path = vault_path
@@ -41,12 +45,24 @@ class NervousNoteSupport:
         self.vault_watcher = VaultWatcher.start(self.vault_path)
         self.file_path = os.path.join(self.vault_path, "Nervous Notes Mqtt Orchestrator.md")
         self.external_messages_actor_ref = ExternalMessages.start(mqtt_config, self.file_path)
-        self.vault_router = VaultRouter.start()
+        self.nervous_note_router = NervousNoteRouter.start()
+
+    def wake(self, cls, note_name: str, *args: Any, **kwargs: Any):
+        with self.lock:
+            if note_name in self.actor_cache:
+                logging.warning(f"[nervous_note.wake] Fetching {note_name} from cache, ignoring *args and **kwargs: {args} {kwargs}")
+                # FIXME: send *args and **kwargs to the actor to let it know about the double-wake?
+                #  should also document/rename wake being different from start() (which also answers the uniform interface question)
+                return self.actor_cache[note_name]
+            else:
+                actor_ref = cls.start(note_name, *args, **kwargs)
+                self.actor_cache[note_name] = actor_ref
+                return actor_ref
 
     def stop(self):
         self.vault_watcher.stop()
         self.external_messages_actor_ref.stop()
-        self.vault_router.stop()
+        self.nervous_note_router.stop()
 
 
 class NervousNote(pykka.ThreadingActor):
@@ -58,7 +74,8 @@ class NervousNote(pykka.ThreadingActor):
             vault_path: str,
             mqtt_config: MqttConfig,
     ):
-        assert cls.support is None, "Background actors already started"  # FIXME: make this idempotent?
+        # FIXME: make this idempotent? probably not, but document in a [[Design Decisions]] note
+        assert cls.support is None, "Background actors already started"
         cls.support = NervousNoteSupport(vault_path, mqtt_config)
 
     @classmethod
@@ -77,15 +94,18 @@ class NervousNote(pykka.ThreadingActor):
     ) -> ActorRef[Actor]:
         assert cls.support is not None, "Did you run NervousNote.start_background_actors(vault_path, mqtt_config)?"
 
-        # .start() comes from pykka.ThreadingActor
-        actor_ref = cls.start(note_name,
-                              # e.g. this is where e.g. ScriptedNote.scripts_dir gets passed through
-                              *args, **kwargs)
+        # idempotency - grab from cache if existing
+        actor_ref = cls.support.wake(cls, note_name,
+                                     # e.g. this is where e.g. ScriptedNote.scripts_dir gets passed through
+                                     *args, **kwargs)
 
         # a NervousNote adds events from mqtt and note updates
         # FIXME: ...and timers??!
+        # FIXME: this is more convenient for a batch publisher anyway since the default_topic is more complicated than the note name
         cls.support.vault_watcher.tell(VaultNoteSubscription(note_name, actor_ref))
 
+        cls.support.nervous_note_router.tell(NervousNoteSubscription(note_name, actor_ref))
+
         default_topic = _default_topic(cls.support.vault_name, note_name)
         cls.support.external_messages_actor_ref.tell(MqttSubscription(default_topic, actor_ref))
 

nervous_notes-0.0.3/src/nervous_notes/nervous_note_router.py

@@ -0,0 +1,50 @@
+import logging
+from collections import defaultdict
+from dataclasses import dataclass
+from typing import Any
+
+from pykka import ActorRef, ThreadingActor
+
+
+@dataclass
+class NervousNoteSubscription:
+    note_id: str
+    subscriber: ActorRef
+
+
+@dataclass
+class PublishToNervousNote:
+    note_id: str  # important for snoopers
+    payload: Any
+
+
+@dataclass
+class MessageBatch:
+    messages: list[Any]
+
+
+@dataclass
+class BatchPublishToNervousNote:
+    note_id: str  # important for snoopers
+    messages: MessageBatch
+
+    @staticmethod
+    def of(note_id: str, messages: list[Any]):
+        return BatchPublishToNervousNote(note_id, MessageBatch(messages))
+
+
+class NervousNoteRouter(ThreadingActor):
+    def __init__(self):
+        super().__init__()
+        # FIXME since I'm changing things up anyway, a NervousNoteRef (or whatever) should probably include note_id
+        self.subscribers: dict[str, set[ActorRef]] = defaultdict(set)
+
+    def on_receive(self, message):
+        if isinstance(message, NervousNoteSubscription):
+            # a NervousNote subscribes to its own [[Note Name]] by default, but we allow for snoopers (for now)
+            self.subscribers[message.note_id].add(message.subscriber)
+        elif isinstance(message, (PublishToNervousNote, BatchPublishToNervousNote)):
+            for subscriber in self.subscribers[message.note_id]:
+                subscriber.tell(message)
+        else:
+            logging.warning(f"Unknown message type: {type(message)}")

{nervous_notes-0.0.2 → nervous_notes-0.0.3}/src/nervous_notes/note_companion_script.py

@@ -8,6 +8,7 @@ from pykka import ActorRef, ActorDeadError
 from watchdog.events import FileModifiedEvent, FileCreatedEvent
 
 from .nervous_note import NervousNote, MqttWrapper
+from .nervous_note_router import BatchPublishToNervousNote, PublishToNervousNote
 from .wrappers.note_api import NoteAPI
 from .wrappers.scripting import ScriptHarness, ScriptPath
 from .wrappers.external_messages import MqttPublish
@@ -33,7 +34,7 @@ class NoteCompanionScript(NervousNote):
             self.script_wrapper = ScriptedNoteHarness(
                 self.actor_ref, self.my_note,
                 self.topic, self.mqtt,
-                self.support.vault_router,
+                self.support.nervous_note_router,
                 self.script_path,
             )
             self.script_wrapper.on_start()
@@ -53,6 +54,9 @@ class NoteCompanionScript(NervousNote):
         elif message == "SCRIPT_MODIFIED":
             logging.info(f"Hot reloading [[{self.note_name}]]")
             self.script_wrapper.compile_script(this_is_a_recompile=True)
+        elif isinstance(message, (PublishToNervousNote, BatchPublishToNervousNote)):
+            # FIXME: worth renaming script_wrapper.on_other_message if it's really this specific?
+            self.script_wrapper.on_other_message(message)
         else:
             try:
                 message_type, key, payload = message
@@ -117,6 +121,7 @@ class NoteCompanionScriptsManager(NervousNote):
                             logging.warning(f"{maybe_note_name} was not in {list(self.nervous_notes.keys())}")
                             raise
                         except ActorDeadError:
+                            # FIXME: do I need to log the exception here, or just an error?
                             logging.exception(f"{maybe_note_name} is dead, could not send a FileModifiedEvent to it")
                         logging.warning(f"NOT HOT RELOADING {message.src_path}")  # FIXME - it DOES get hotreloaded, doesn't it?
                     else:
@@ -130,21 +135,23 @@ class NoteCompanionScriptsManager(NervousNote):
             if message.src_path.startswith(self.support.vault_path):
                 pass  # FIXME - on_note_created event?
             elif message.src_path.startswith(self.scripts_dir):
-                script_path_to_wake = message.src_path
-                note_name: str = os.path.splitext(os.path.split(script_path_to_wake)[1])[0]
-                if note_name in self.nervous_notes:
-                    logging.warning(f"Got a file created event for script {script_path_to_wake} but it was already created (ignoring)")
-                else:
-                    logging.info(f"Detected new script {script_path_to_wake}, loading it and adding it for hotreloading...")
-                    actor_ref = NoteCompanionScript.wake(
-                        note_name,
-                        ScriptPath(self.scripts_dir, note_name)
-                    )
-                    self.nervous_notes[note_name] = actor_ref
-                    self.__update_note()
+                # FIXME: gate starting new .py scripts behind [[Note Companion Scripts Manager]]
+                logging.warning(f"Ignoring {message.src_path}, restart the app to load the new script")
+                # script_path_to_wake = message.src_path
+                # note_name: str = os.path.splitext(os.path.split(script_path_to_wake)[1])[0]
+                # if note_name in self.nervous_notes:
+                #     logging.warning(f"Got a file created event for script {script_path_to_wake} but it was already created (ignoring)")
+                # else:
+                #     logging.info(f"Detected new script {script_path_to_wake}, loading it and adding it for hotreloading...")
+                #     actor_ref = NoteCompanionScript.wake(
+                #         note_name,
+                #         ScriptPath(self.scripts_dir, note_name)
+                #     )
+                #     self.nervous_notes[note_name] = actor_ref
+                #     self.__update_note()
             else:
-                logging.warning(
-                    f"unexpected new path `{message.src_path}` (did not start with scripts dir `{self.scripts_dir}` or vault dir `{self.support.vault_path}`)")
+                logging.warning(f"unexpected new path `{message.src_path}` (did not start with scripts dir `{self.scripts_dir}` or "
+                                f"vault dir `{self.support.vault_path}`)")
         elif isinstance(message, MqttPublish):
             self.on_mqtt_message(message.topic, message.payload)
         else:
@@ -172,22 +179,22 @@ class NoteCompanionScriptsManager(NervousNote):
 
 
 class ScriptedNoteHarness(ScriptHarness):
-    def __init__(self, actor_ref: ActorRef, my_note: NoteAPI, topic: str, mqtt: MqttWrapper, vault_router: ActorRef, script_path: ScriptPath):
-        super().__init__(actor_ref, my_note, topic, mqtt, vault_router, script_path)
+    def __init__(self, actor_ref: ActorRef, my_note: NoteAPI, topic: str, mqtt: MqttWrapper, nervous_note_router: ActorRef, script_path: ScriptPath):
+        super().__init__(actor_ref, my_note, topic, mqtt, nervous_note_router, script_path)
         self._scripts = []
-        self.script_scope["wake"] = self.__wake_subordinate
+        self.script_scope["wake"] = self.__wake
         self.script_scope["TemplateScript"] = TemplateScript
 
-    def __wake_subordinate(self, filename: str, template_script: TemplateScript) -> ActorRef:
+    def __wake(self, filename: str, template_script: TemplateScript) -> ActorRef:
         if isinstance(template_script, TemplateScript):
-            script = NoteCompanionScript.wake(  # FIXME: fk wake->start if possible!
+            script = NoteCompanionScript.wake(
                 filename,
                 ScriptPath(os.path.join(self.script_path.scripts_dir, "templates"), template_script.script_name)
             )
             self._scripts.append(script)
             return script
         else:
-            raise NotImplementedError
+            raise NotImplementedError(f"Only TemplateScript templates are supported currently")
 
     def get_script(self) -> str:
         with open(self.script_path.script_path) as f:

{nervous_notes-0.0.2 → nervous_notes-0.0.3}/src/nervous_notes/note_embedded_script.py

@@ -53,7 +53,7 @@ class NoteEmbeddedScript(NervousNote):
 
         self.script_wrapper = NoteEmbeddedScriptHarness(self.actor_ref, self.my_note,
                                                         self.topic, self.mqtt,
-                                                        self.support.vault_router)
+                                                        self.support.nervous_note_router)
         self.script_wrapper.on_start()
 
     def on_receive(self, message):
@@ -85,8 +85,8 @@ class NoteEmbeddedScript(NervousNote):
 
 
 class NoteEmbeddedScriptHarness(ScriptHarness):
-    def __init__(self, actor_ref: ActorRef, my_note: NoteAPI, topic: str, mqtt: MqttWrapper, vault_router: ActorRef):
-        super().__init__(actor_ref, my_note, topic, mqtt, vault_router, f"{my_note.note_path}#Code")
+    def __init__(self, actor_ref: ActorRef, my_note: NoteAPI, topic: str, mqtt: MqttWrapper, nervous_note_router: ActorRef):
+        super().__init__(actor_ref, my_note, topic, mqtt, nervous_note_router, f"{my_note.note_path}#Code")
 
     def get_script(self) -> str:
         with open(self.my_note.note_path) as f:

{nervous_notes-0.0.2 → nervous_notes-0.0.3}/src/nervous_notes/orchestration.py

@@ -20,7 +20,7 @@ class Orchestrator(NervousNote):
         # this runs in the spawner's context, whereas on_start runs in the actor thread
         super().__init__(note_name, *args, **kwargs)
 
-        self.scripts_dir = scripts_dir
+        self.scripts_dir = os.path.abspath(scripts_dir)
         self.libraries_dir = libraries_dir
         self.started = []
         self.deploy_debug_notes = deploy_debug_notes

{nervous_notes-0.0.2 → nervous_notes-0.0.3}/src/nervous_notes/wrappers/external_messages.py

@@ -86,6 +86,7 @@ class ExternalMessages(pykka.ThreadingActor):
         if isinstance(msg, MqttSubscription):
             if self.mqtt_client is not None:
                 logging.debug(f"Subscribing to {msg.topic}: {msg.subscriber}")
+                # FIXME: how best to handle a user accidentally providing a list typed topic?
                 self.mqtt_client.subscribe(msg.topic)
                 self.subscribers[msg.topic].add(msg.subscriber)
                 self.my_note.append(f"- \\[{ctime()}] subscribed to `{msg.topic}`: {msg.subscriber}\n")
@@ -93,8 +94,12 @@ class ExternalMessages(pykka.ThreadingActor):
                 logging.warning(f"Ignoring subscription to {msg.topic}, no mqtt config")
         elif isinstance(msg, MqttPublish):
             if self.mqtt_client is not None:
-                self.mqtt_client.publish(msg.topic, msg.payload)
-                logging.debug(f"published {len(msg.payload)} bytes to `{msg.topic}`")
+                try:
+                    self.mqtt_client.publish(msg.topic, msg.payload)
+                except Exception as e:
+                    logging.exception(f"Failed to publish {msg.topic} ({type(msg.topic)}): {e}")
+                else:
+                    logging.debug(f"published {len(msg.payload)} bytes to `{msg.topic}`")
             else:
                 logging.warning(f"Ignoring publish to {msg.topic}, no mqtt config")
         else:

{nervous_notes-0.0.2 → nervous_notes-0.0.3}/src/nervous_notes/wrappers/note_api.py

@@ -246,8 +246,6 @@ def _raw_note_to_frontmatter_and_markdown(raw_note_lines) -> Tuple[str | None, s
             frontmatter_lines.append(line)
 
         frontmatter = ''.join(frontmatter_lines)
-    else:
-        raise Exception("no end to frontmatter")
 
     markdown = ''.join(raw_note_lines)  # remaining
     return frontmatter, markdown

{nervous_notes-0.0.2 → nervous_notes-0.0.3}/src/nervous_notes/wrappers/scripting.py

@@ -12,7 +12,7 @@ from typing import TYPE_CHECKING  # FIXME: remove
 from pykka import ActorRef
 
 from ..util import Clock, TimeUtil
-from ..vault_router import Subscribe, Publish
+from ..nervous_note_router import NervousNoteSubscription, PublishToNervousNote, BatchPublishToNervousNote
 from ..nervous_note import MqttWrapper
 from ..wrappers.note_api import NoteAPI, datetimestamped_markdown_list_line, timestamped_markdown_list_line
 
@@ -34,7 +34,7 @@ class ScriptPath:
 class ScriptHarness:
     my_note: NoteAPI
 
-    def __init__(self, actor_ref: ActorRef, my_note: NoteAPI, topic: str, mqtt: MqttWrapper, vault_router: ActorRef, script_path: ScriptPath):
+    def __init__(self, actor_ref: ActorRef, my_note: NoteAPI, topic: str, mqtt: MqttWrapper, nervous_note_router: ActorRef, script_path: ScriptPath):
         self.my_note = my_note
         self.script_path = script_path
         self.actor_ref = actor_ref
@@ -64,8 +64,9 @@ class ScriptHarness:
             "cancel_timer": self.cancel_timer,
             "datetimestamped_markdown_list_line": datetimestamped_markdown_list_line,
             "timestamped_markdown_list_line": timestamped_markdown_list_line,
-            "subscribe_internal": lambda t, s: vault_router.tell(Subscribe(t, s)),
-            "publish_internal": lambda t, p: vault_router.tell(Publish(t, p)),
+            # "snoop_on_nervous_note": lambda nid, s: nervous_note_router.tell(NervousNoteSubscription(nid, s)),
+            "publish_to_nervous_note": lambda nid, p: nervous_note_router.tell(PublishToNervousNote(nid, p)),
+            "batch_publish_to_nervous_note": lambda nid, batch: nervous_note_router.tell(BatchPublishToNervousNote.of(nid, batch)),
             "publish_to_ntfy": publish_to_ntfy,
             "next_occurrence": timeutil.next_occurrence,
             "seconds_until": timeutil.seconds_until,
@@ -78,6 +79,7 @@ class ScriptHarness:
             "on_start": lambda: None,
             "on_timer": lambda key, payload: None,
             "on_stop": lambda: None,
+            "on_other_message": lambda: None,
         }
 
         self.prior_script = None
@@ -120,8 +122,12 @@ class ScriptHarness:
             else:
                 logging.info(f"{self.script_path} compilation complete, executing to update the scope now...")
             # this may update the scope with potentially new on* event functions
-            exec(self.compiled_script, self.script_scope)
-            self.prior_script = script
+            try:
+                exec(self.compiled_script, self.script_scope)
+            except Exception as e:
+                logging.exception(f"Failed to compile {self.script_path} ({e})")
+            else:
+                self.prior_script = script
 
     def on_start(self) -> None:
         try:
@@ -151,6 +157,12 @@ class ScriptHarness:
     def on_stop(self) -> None:
         logging.info(f"stopping ScriptHarness")
 
+    def on_other_message(self, message) -> None:
+        try:
+            self.script_scope["on_other_message"](message)
+        except Exception as e:
+            logging.exception(f"on_other_message call failed {e}")
+
 
 # FIXME: move to "services" or something, with weather, PurpleAir, etc
 def publish_to_ntfy(channel: str, message: str) -> None:

nervous_notes-0.0.2/src/nervous_notes/vault_router.py

@@ -1,33 +0,0 @@
-import logging
-from collections import defaultdict
-from dataclasses import dataclass
-from typing import Set, Dict
-
-from pykka import ActorRef, ThreadingActor
-
-
-@dataclass
-class Subscribe:
-    topic: str
-    subscriber: ActorRef
-
-
-@dataclass
-class Publish:
-    topic: str
-    payload: object
-
-
-class VaultRouter(ThreadingActor):
-    def __init__(self):
-        super().__init__()
-        self.subscribers: Dict[str, Set[ActorRef]] = defaultdict(set)
-
-    def on_message(self, message):
-        if isinstance(message, Subscribe):
-            self.subscribers[message.topic].add(message.subscriber)
-        elif isinstance(message, Publish):
-            for subscriber in self.subscribers[message.topic]:
-                subscriber.tell(message.payload)
-        else:
-            logging.warning(f"Unknown message type: {type(message)}")