added support for multi-type waiting plus some cleanup

core/meow.py

@@ -1,11 +1,11 @@
 
-from multiprocessing.connection import Connection
 from typing import Any
 
 from core.correctness.vars import VALID_RECIPE_NAME_CHARS, \
-    VALID_PATTERN_NAME_CHARS, VALID_RULE_NAME_CHARS, \
-    get_not_imp_msg, get_drt_imp_msg
-from core.correctness.validation import valid_string
+    VALID_PATTERN_NAME_CHARS, VALID_RULE_NAME_CHARS, VALID_CHANNELS, \
+    get_drt_imp_msg
+from core.correctness.validation import valid_string, check_type, \
+    check_implementation
 
 
 class BaseRecipe:
@@ -15,15 +15,9 @@ class BaseRecipe:
     requirements:dict[str, Any]
     def __init__(self, name:str, recipe:Any, parameters:dict[str,Any]={}, 
             requirements:dict[str,Any]={}):
-        if (type(self)._is_valid_recipe == BaseRecipe._is_valid_recipe):
-            msg = get_not_imp_msg(BaseRecipe, BaseRecipe._is_valid_recipe)
-            raise NotImplementedError(msg)
-        if (type(self)._is_valid_parameters == BaseRecipe._is_valid_parameters):
-            msg = get_not_imp_msg(BaseRecipe, BaseRecipe._is_valid_parameters)
-            raise NotImplementedError(msg)
-        if (type(self)._is_valid_requirements == BaseRecipe._is_valid_requirements):
-            msg = get_not_imp_msg(BaseRecipe, BaseRecipe._is_valid_requirements)
-            raise NotImplementedError(msg)
+        check_implementation(type(self)._is_valid_recipe, BaseRecipe)
+        check_implementation(type(self)._is_valid_parameters, BaseRecipe)
+        check_implementation(type(self)._is_valid_requirements, BaseRecipe)
         self._is_valid_name(name)
         self.name = name
         self._is_valid_recipe(recipe)
@@ -55,19 +49,13 @@ class BaseRecipe:
 class BasePattern:
     name:str
     recipe:str
-    parameters:dict[str, Any]
-    outputs:dict[str, Any]
+    parameters:dict[str,Any]
+    outputs:dict[str,Any]
     def __init__(self, name:str, recipe:str, parameters:dict[str,Any]={}, 
             outputs:dict[str,Any]={}):
-        if (type(self)._is_valid_recipe == BasePattern._is_valid_recipe):
-            msg = get_not_imp_msg(BasePattern, BasePattern._is_valid_recipe)
-            raise NotImplementedError(msg)
-        if (type(self)._is_valid_parameters == BasePattern._is_valid_parameters):
-            msg = get_not_imp_msg(BasePattern, BasePattern._is_valid_parameters)
-            raise NotImplementedError(msg)
-        if (type(self)._is_valid_output == BasePattern._is_valid_output):
-            msg = get_not_imp_msg(BasePattern, BasePattern._is_valid_output)
-            raise NotImplementedError(msg)
+        check_implementation(type(self)._is_valid_recipe, BasePattern)
+        check_implementation(type(self)._is_valid_parameters, BasePattern)
+        check_implementation(type(self)._is_valid_output, BasePattern)
         self._is_valid_name(name)
         self.name = name
         self._is_valid_recipe(recipe)
@@ -103,13 +91,8 @@ class BaseRule:
     pattern_type:str=""
     recipe_type:str=""
     def __init__(self, name:str, pattern:BasePattern, recipe:BaseRecipe):
-        if (type(self)._is_valid_pattern == BaseRule._is_valid_pattern):
-            msg = get_not_imp_msg(BaseRule, BaseRule._is_valid_pattern)
-            raise NotImplementedError(msg)
-        if (type(self)._is_valid_recipe == BaseRule._is_valid_recipe):
-            msg = get_not_imp_msg(BaseRule, BaseRule._is_valid_recipe)
-            raise NotImplementedError(msg)
-
+        check_implementation(type(self)._is_valid_pattern, BaseRule)
+        check_implementation(type(self)._is_valid_recipe, BaseRule)
         self._is_valid_name(name)
         self.name = name
         self._is_valid_pattern(pattern)
@@ -144,29 +127,15 @@ class BaseRule:
 
 class BaseMonitor:
     rules: dict[str, BaseRule]
-    report: Connection
-    listen: Connection
-    def __init__(self, rules:dict[str, BaseRule], report:Connection, 
-            listen:Connection) -> None:
-        if (type(self).start == BaseMonitor.start):
-            msg = get_not_imp_msg(BaseMonitor, BaseMonitor.start)
-            raise NotImplementedError(msg)
-        if (type(self).stop == BaseMonitor.stop):
-            msg = get_not_imp_msg(BaseMonitor, BaseMonitor.stop)
-            raise NotImplementedError(msg)
-        if (type(self)._is_valid_report == BaseMonitor._is_valid_report):
-            msg = get_not_imp_msg(BaseMonitor, BaseMonitor._is_valid_report)
-            raise NotImplementedError(msg)
+    report: VALID_CHANNELS
+    def __init__(self, rules:dict[str,BaseRule], 
+            report:VALID_CHANNELS)->None:
+        check_implementation(type(self).start, BaseMonitor)
+        check_implementation(type(self).stop, BaseMonitor)
+        check_implementation(type(self)._is_valid_report, BaseMonitor)
+        check_implementation(type(self)._is_valid_rules, BaseMonitor)
         self._is_valid_report(report)
         self.report = report
-        if (type(self)._is_valid_listen == BaseMonitor._is_valid_listen):
-            msg = get_not_imp_msg(BaseMonitor, BaseMonitor._is_valid_listen)
-            raise NotImplementedError(msg)
-        self._is_valid_listen(listen)
-        self.listen = listen
-        if (type(self)._is_valid_rules == BaseMonitor._is_valid_rules):
-            msg = get_not_imp_msg(BaseMonitor, BaseMonitor._is_valid_rules)
-            raise NotImplementedError(msg)
         self._is_valid_rules(rules)
         self.rules = rules
         
@@ -176,13 +145,10 @@ class BaseMonitor:
             raise TypeError(msg)
         return object.__new__(cls)
 
-    def _is_valid_report(self, report:Connection)->None:
+    def _is_valid_report(self, report:VALID_CHANNELS)->None:
         pass
 
-    def _is_valid_listen(self, listen:Connection)->None:
-        pass
-
-    def _is_valid_rules(self, rules:dict[str, BaseRule])->None:
+    def _is_valid_rules(self, rules:dict[str,BaseRule])->None:
         pass
 
     def start(self)->None:
@@ -194,13 +160,11 @@ class BaseMonitor:
 
 class BaseHandler:
     inputs:Any
-    def __init__(self, inputs:Any) -> None:
-        if (type(self).handle == BaseHandler.handle):
-            msg = get_not_imp_msg(BaseHandler, BaseHandler.handle)
-            raise NotImplementedError(msg)
-        if (type(self)._is_valid_inputs == BaseHandler._is_valid_inputs):
-            msg = get_not_imp_msg(BaseHandler, BaseHandler._is_valid_inputs)
-            raise NotImplementedError(msg)
+    def __init__(self, inputs:list[VALID_CHANNELS]) -> None:
+        check_implementation(type(self).start, BaseHandler)
+        check_implementation(type(self).stop, BaseHandler)
+        check_implementation(type(self).handle, BaseHandler)
+        check_implementation(type(self)._is_valid_inputs, BaseHandler)
         self._is_valid_inputs(inputs)
         self.inputs = inputs
 
@@ -213,5 +177,34 @@ class BaseHandler:
     def _is_valid_inputs(self, inputs:Any)->None:
         pass
 
-    def handle()->None:
+    def handle(self, event:Any, rule:BaseRule)->None:
         pass
+
+    def start(self)->None:
+        pass
+
+    def stop(self)->None:
+        pass
+
+
+# TODO test me
+class MeowRunner:
+    monitor:BaseMonitor
+    handler:BaseHandler
+    def __init__(self, monitor:BaseMonitor, handler:BaseHandler) -> None:
+        self._is_valid_monitor(monitor)
+        self.monitor = monitor
+        self._is_valid_handler(handler)
+        self.handler = handler
+
+    def start(self)->None:
+        self.monitor.start()
+
+    def stop(self)->None:
+        self.monitor.stop()
+
+    def _is_valid_monitor(self, monitor:BaseMonitor)->None:
+        check_type(monitor, BaseMonitor)
+
+    def _is_valid_handler(self, handler:BaseHandler)->None:
+        check_type(handler, BaseHandler)