master > master: struktur + unit tests

code/main.py

@@ -8,43 +8,65 @@
 from __future__ import annotations;
 import os;
 import sys;
-sys.tracebacklimit = 0;
+# sys.tracebacklimit = 0;
+from dotenv import dotenv_values;
 from lark import Tree;
 from textwrap import dedent;
 from typing import List;
 
 sys.path.insert(0, os.getcwd());
 
-from schema import string_to_parts;
+from aussagenlogik.schema import string_to_parts;
+from aussagenlogik.rekursion import rekursiv_eval;
+from aussagenlogik.rekursion import rekursiv_atoms;
+from aussagenlogik.rekursion import rekursiv_depth;
+from aussagenlogik.rekursion import rekursiv_length;
+from aussagenlogik.rekursion import rekursiv_parentheses;
 
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# GLOBAL CONSTANTS
+# GLOBALE KONSTANTEN
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-# zeichenkette = 'A0';
-# zeichenkette = '! A0';
-# zeichenkette = '( A0 && A1 )';
-# zeichenkette = '( A0 || A1 )';
-# zeichenkette = '( A0 -> A1 )';
-zeichenkette = '( A0 -> ((A0 && A3) || ! A2) )';
-# zeichenkette = '( A0 -> ((A0 && A3) || A2) )';
-# zeichenkette = '(( {G} || !{G} ) -> A5)';
-
-I = ['A0', 'A2'];
+DATA_ENV = "data.env"; # Pfad zu Daten.
 
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 # HAUPTVORGANG
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 def main():
-    tree = string_to_parts(zeichenkette);
+    ## Daten einlesen:
+    expr, I = getData();
+    ## Formel in Teilformeln zerlegen:
+    tree = string_to_parts(expr);
+    ## Methoden ausführen:
+    results = dict(
+        eval  = rekursiv_eval(tree, I),
+        atoms = rekursiv_atoms(tree),
+        d     = rekursiv_depth(tree),
+        l     = rekursiv_length(tree),
+        p     = rekursiv_parentheses(tree),
+    );
+    ## Resultate anzeigen:
+    display_results(expr, tree, I, results);
+    return;
+
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# SONSTIGE METHODEN
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+def getData():
+    data = dotenv_values(dotenv_path=DATA_ENV);
+    expr = data['expr'] or '0';
+    I = eval(data['interpretation'] or '[]');
+    return expr, I;
+
+def display_results(expr: str, tree: Tree, I: List[str], results: dict):
     print(dedent(
         '''
         Syntaxbaum von
             F := \033[92;1m{F}\033[0m:
-        '''.format(
-            F=zeichenkette,
-        )
+        '''.format(F=expr)
     ));
     print(tree.pretty());
     print(dedent(
@@ -56,74 +78,11 @@ def main():
         \033[2m#parentheses(F) = \033[94;1m{p}\033[0m;  \033[91;1m<- *\033[0m
 
         \033[91;1m*\033[0m \033[2mnoch nicht implementiert!\033[0m
-        \033[1;2;4mChallenge:\033[0m \033[2mschreibe diese Methoden. Probiere mit Stift-und-Zettel die Methoden händisch auszuführen und vergleiche mit dem Code-Output.\033[0m
-        '''.format(
-            eval  = rekursiv_eval(tree, I),
-            atoms = rekursiv_atoms(tree),
-            d     = rekursiv_depth(tree),
-            l     = rekursiv_length(tree),
-            p     = rekursiv_parentheses(tree),
-        )
+        \033[1;2;4mChallenge:\033[0m \033[2mschreibe diese Methoden! (siehe README.md)\033[0m
+        '''.format(**results)
     ));
     return;
 
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# SEKUNDÄRVORGÄNGE
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-def rekursiv_atoms(fml: Tree) -> List[str]:
-    ## Herausforderung: schreibe diese Funktion!
-    return [];
-
-def rekursiv_depth(fml: Tree) -> int:
-    ## Herausforderung: schreibe diese Funktion!
-    return 0;
-
-def rekursiv_length(fml: Tree) -> int:
-    ## Herausforderung: schreibe diese Funktion!
-    return 0;
-
-def rekursiv_parentheses(fml: Tree) -> int:
-    ## Herausforderung: schreibe diese Funktion!
-    return 0;
-
-def rekursiv_eval(fml: Tree, I: List[str]) -> int:
-    teilfml = getTeilformeln(fml);
-    if fml.data in ['atom', 'beliebig']:
-        name = fml.children[0];
-        return 1 if (name in I) else 0;
-    elif fml.data == 'wahr':
-        return 1;
-    elif fml.data == 'falsch':
-        return 0;
-    elif fml.data == 'negation':
-        val1 = rekursiv_eval(teilfml[0], I);
-        return 1 - val1;
-    elif fml.data == 'konjunktion':
-        val1 = rekursiv_eval(teilfml[0], I);
-        val2 = rekursiv_eval(teilfml[1], I);
-        return min(val1, val2);
-    elif fml.data == 'disjunktion':
-        val1 = rekursiv_eval(teilfml[0], I);
-        val2 = rekursiv_eval(teilfml[1], I);
-        return max(val1, val2);
-    elif fml.data == 'implikation':
-        val1 = rekursiv_eval(teilfml[0], I);
-        val2 = rekursiv_eval(teilfml[1], I);
-        return 0 if val1 == 1 and val2 == 0 else 1;
-    raise Exception('Evaluation nicht möglich!');
-
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# SONSTIGE METHODEN
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-def getTeilformeln(fml: Tree) -> List[Tree]:
-    return [
-        part for part in fml.children
-        if isinstance(part, Tree)
-        and not part.data == 'junktor'
-    ];
-
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 # CODE AUSFÜHREN
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~