Merge pull request #58 from da-h/event_register_in_event

Dynamic Event Registration

src/miniflask/event.py

@@ -64,7 +64,7 @@ def __getattr__(self, name):  # noqa: C901 too-complex  pylint: disable=too-many
 
             # fn_wrap_scope creates a function wrap of fn that passes also state and event of eobj
             # additionally, if outervar is defined as a default, it queries that from the last outer scope
-            def fn_wrap_scope(fn, _state, _event, module, needed_locals=None, miniflask_args=None, skip_twice=False, call_before_after=call_before_after):  # pylint: disable=too-many-statements
+            def fn_wrap_scope(fn, _mf, _state, _event, module, needed_locals=None, miniflask_args=None, skip_twice=False, call_before_after=call_before_after):  # pylint: disable=too-many-statements
                 del module  # unused
                 if needed_locals is None:
                     needed_locals = []
@@ -96,15 +96,11 @@ def fn_wrap_scope(fn, _state, _event, module, needed_locals=None, miniflask_args
                 fn_before = getattr(self._mf.event, name_before) if has_before else None
 
                 # get index of "state" / "event"
-                if len(arg_names) > 0:
-                    if arg_names[0] == "state":
-                        miniflask_args.append(_state)
-                        if len(arg_names) > 1 and arg_names[1] == "event":
-                            miniflask_args.append(_event)
-                    elif arg_names[0] == "event":
-                        miniflask_args.append(_event)
-                        if len(arg_names) > 1 and arg_names[1] == "state":
-                            miniflask_args.append(_state)
+                for i in range(min(len(arg_names), 3)):
+                    for var, varname in [(_mf, "mf"), (_state, "state"), (_event, "event")]:
+                        if arg_names[i] == varname:
+                            miniflask_args.append(var)
+                            break
 
                 # if no outervar found, just pass state and event
                 if len(needed_locals) > 0:
@@ -147,15 +143,15 @@ def fn_wrap(*args, altfn=None, **kwargs):
                 return fn_wrap, has_signature, miniflask_args
 
             if eobj.unique:
-                fn_wrap, has_signature, mf_args = fn_wrap_scope(eobj.fn, eobj.modules.state, eobj.modules.event, eobj.modules)
+                fn_wrap, has_signature, mf_args = fn_wrap_scope(eobj.fn, eobj.modules, eobj.modules.state, eobj.modules.event, eobj.modules)
                 if has_signature:
                     setattr(fn_wrap, 'mf_modules', [eobj.modules.module_id])
                     setattr(fn_wrap, 'subevents', [fn_wrap])
                     setattr(fn_wrap, 'fns', [eobj.fn])
                     setattr(fn_wrap, 'fns_args', [mf_args])
             else:
                 def multiple_fn_wrap_scope(orig_fns, modules=eobj.modules):
-                    fns, have_signature, mf_args = zip(*[fn_wrap_scope(fn, _state=module.state, _event=module.event, module=module, skip_twice=True) for fn, module in zip(orig_fns, modules)])
+                    fns, have_signature, mf_args = zip(*[fn_wrap_scope(fn, _mf=module, _state=module.state, _event=module.event, module=module, skip_twice=True) for fn, module in zip(orig_fns, modules)])
 
                     def fn_wrap(*args, altfn=None, **kwargs):
                         del altfn  # unused

src/miniflask/miniflask.py

@@ -80,7 +80,6 @@ def __init__(self, module_dirs, debug=False):
         self.modules_loaded = {}
         self.modules_ignored = []
         self.modules_avail = getModulesAvail(self.module_dirs)
-        self.miniflask_objs = {}  # local modified versions of miniflask
         registerPredefined(self.modules_avail)
         self._varid_list = []
         self._recently_loaded = []
@@ -892,8 +891,25 @@ def load(self, module_name, as_id=None, auto_query=True, **kwargs):
             del kwargs["verbose"]
         super().load(module_name, verbose=False, auto_query=auto_query, as_id=as_id, **kwargs)
 
-    # overwrite state defaults
+    def unregister_event(self, name, only_cache):
+        if hasattr(self.event, name):
+            delattr(self.event, name)
+        if not only_cache and name in self.event_objs:
+            del self.event_objs[name]
+        if "before_" + name in self.event_objs:
+            self.unregister_event("before_" + name, only_cache)
+        if "after_" + name in self.event_objs:
+            self.unregister_event("after_" + name, only_cache)
+
+    # define event
     def register_event(self, name, fn, **kwargs):
+        self.unregister_event(name, only_cache=True)
+        self._defined_events[name] = fn
+        super().register_event(name, fn, **kwargs)
+
+    # overwrite event definition
+    def overwrite_event(self, name, fn, **kwargs):
+        self.unregister_event(name, only_cache=False)
         self._defined_events[name] = fn
         super().register_event(name, fn, **kwargs)
 

tests/test_event/modules/register_event_during_event/__init__.py

@@ -0,0 +1,21 @@
+
+def test(i):
+    print("test", i)
+
+
+def add_test(mf):
+    def add_test_print(i):
+        print("added to test", i)
+    mf.register_event("test", add_test_print)
+
+
+def main(event):
+    event.test(0)
+    event.add_test()
+    event.test(1)
+
+
+def register(mf):
+    mf.register_event("test", test)
+    mf.register_event("add_test", add_test)
+    mf.register_event("main", main)

tests/test_event/test_register_event_during_event.py

@@ -0,0 +1,18 @@
+from pathlib import Path
+import miniflask  # noqa: E402
+
+
+def init_mf():
+    return miniflask.init(module_dirs=str(Path(__file__).parent / "modules"), debug=True)
+
+
+def test_register_event_during_event(capsys):
+    mf = init_mf()
+    mf.run(argv=[], modules=["register_event_during_event"])
+    captured = capsys.readouterr()
+    out = """
+test 0
+test 1
+added to test 1
+"""
+    assert out in captured.out