Fix(Core): refact MO, clean import and fix renders

Split MO in 2 categories Atoms and Molecules

mapytex/calculus/core/renders/tree2tex.py

@@ -13,19 +13,19 @@ __all__ = ['tree2tex']
 def plus2tex(left, right):
     r""" + rendering
 
-    >>> from ..MO import mo
-    >>> plus2tex(mo.MOnumber(2), mo.MOnumber(3))
+    >>> from ..MO import MO
+    >>> plus2tex(MO.factory(2), MO.factory(3))
     '2 + 3'
     >>> from ..tree import Tree
     >>> t = Tree.from_str("1+2")
-    >>> plus2tex(t, mo.MOnumber(3))
+    >>> plus2tex(t, MO.factory(3))
     '1 + 2 + 3'
-    >>> plus2tex(t, mo.MOnumber(-3))
+    >>> plus2tex(t, MO.factory(-3))
     '1 + 2 - 3'
-    >>> plus2tex(mo.MOnumber(-3), t)
+    >>> plus2tex(MO.factory(-3), t)
     '- 3 + 1 + 2'
     >>> t = Tree.from_str("-2*3")
-    >>> plus2tex(mo.MOnumber(3), t)
+    >>> plus2tex(MO.factory(3), t)
     '3 - 2 \\times 3'
     """
     display_plus = True
@@ -54,8 +54,8 @@ def plus2tex(left, right):
 def minus2tex(left, right):
     r""" - rendering
 
-    >>> from ..MO import mo
-    >>> minus2tex(None, mo.MO(3))
+    >>> from ..MO import MO
+    >>> minus2tex(None, MO.factory(3))
     '- 3'
     >>> from ..tree import Tree
     >>> t = Tree.from_str("1+2")
@@ -79,54 +79,30 @@ def minus2tex(left, right):
 def mul2tex(left, right):
     r""" * rendering
 
-    >>> from ..MO import mo
-    >>> mul2tex(mo.MO(2), mo.MO(3))
+    >>> from ..MO import MO
+    >>> mul2tex(MO.factory(2), MO.factory(3))
     '2 \\times 3'
     >>> from ..tree import Tree
     >>> t = Tree.from_str("1*2")
-    >>> mul2tex(t, mo.MO(3))
+    >>> mul2tex(t, MO.factory(3))
     '1 \\times 2 \\times 3'
     >>> t = Tree.from_str("1+2")
-    >>> mul2tex(t, mo.MO(3))
+    >>> mul2tex(t, MO.factory(3))
     '(1 + 2) \\times 3'
-    >>> mul2tex(mo.MO(3), t)
+    >>> mul2tex(MO.factory(3), t)
     '3(1 + 2)'
-    >>> a = mo.MOstr('x')
-    >>> mul2tex(mo.MO(3), a)
+    >>> a = MO.factory('x')
+    >>> mul2tex(MO.factory(3), a)
     '3x'
     >>> mul2tex(a, a)
     'x \\times x'
     """
-    display_time = True
-    try:
-        left_need_parenthesis = False
-        if OPERATORS[left.node]["precedence"] < OPERATORS['*']["precedence"]:
-            left_need_parenthesis = True
-    except AttributeError:
-        left_ = left.__tex__
-    else:
-        if left_need_parenthesis:
-            left_ = f"({tree2tex(left)})"
-        else:
-            left_ = tree2tex(left)
+    left_ = render_with_parenthesis(left, "*")
+    right_ = render_with_parenthesis(right, "*")
 
-    try:
-        right_need_parenthesis = False
-        if OPERATORS[right.node]["precedence"] < OPERATORS['*']["precedence"]:
-            right_need_parenthesis = True
-    except AttributeError:
-        try:
-            right_ = right.__tex__
-        except AttributeError:
-            right_ = right
-    else:
-        if right_need_parenthesis:
-            display_time = False
-            right_ = f"({tree2tex(right)})"
-        else:
-            right_ = tree2tex(right)
-    finally:
-        if right_[0].isalpha() and (left_.isnumeric() or left_.isdecimal()):
+    display_time = True
+    if (right_[0].isalpha() and (left_.isnumeric() or left_.isdecimal())) or \
+            right_[0] == '(':
             display_time = False
 
     if display_time:
@@ -136,18 +112,18 @@ def mul2tex(left, right):
 def div2tex(left, right):
     r""" / rendering
 
-    >>> from ..MO import mo
-    >>> div2tex(mo.MO(2), mo.MO(3))
+    >>> from ..MO import MO
+    >>> div2tex(MO.factory(2), MO.factory(3))
     '\\frac{2}{3}'
     >>> from ..tree import Tree
     >>> t = Tree.from_str("1/2")
-    >>> div2tex(t, mo.MO(3))
+    >>> div2tex(t, MO.factory(3))
     '\\frac{\\frac{1}{2}}{3}'
     >>> t = Tree.from_str("1+2")
-    >>> div2tex(t, mo.MO(3))
+    >>> div2tex(t, MO.factory(3))
     '\\frac{1 + 2}{3}'
     >>> t = Tree.from_str("1*2")
-    >>> div2tex(mo.MO(3), t)
+    >>> div2tex(MO.factory(3), t)
     '\\frac{3}{1 \\times 2}'
     """
     try:
@@ -164,21 +140,21 @@ def div2tex(left, right):
 def pow2tex(left, right):
     r""" ^ rendering
 
-    >>> from ..MO import mo
-    >>> pow2tex(mo.MO(2), mo.MO(3))
+    >>> from ..MO import MO
+    >>> pow2tex(MO.factory(2), MO.factory(3))
     '2^{3}'
     >>> from ..tree import Tree
     >>> t = Tree.from_str("1^2")
-    >>> pow2tex(t, mo.MO(3))
+    >>> pow2tex(t, MO.factory(3))
     '1^{2}^{3}'
     >>> t = Tree.from_str("1^2")
-    >>> pow2tex(mo.MO(3), t)
+    >>> pow2tex(MO.factory(3), t)
     '3^{1^{2}}'
     >>> t = Tree.from_str("1+2")
-    >>> pow2tex(t, mo.MO(3))
+    >>> pow2tex(t, MO.factory(3))
     '(1 + 2)^{3}'
     >>> t = Tree.from_str("1*2")
-    >>> pow2tex(mo.MO(3), t)
+    >>> pow2tex(MO.factory(3), t)
     '3^{1 \\times 2}'
     """
     try:
@@ -202,6 +178,28 @@ def pow2tex(left, right):
 
     return f"{left_}^{{{right_}}}"
 
+
+def render_with_parenthesis(subtree, operator):
+    subtree_need_parenthesis = False
+    try:
+        subtree.node
+    except AttributeError:
+        try:
+            if OPERATORS[subtree.MAINOP]["precedence"] < OPERATORS[operator]["precedence"]:
+                subtree_need_parenthesis = True
+        except (AttributeError, KeyError):
+            pass
+        subtree_ = subtree.__txt__
+    else:
+        if OPERATORS[subtree.node]["precedence"] < OPERATORS[operator]["precedence"]:
+            subtree_need_parenthesis = True
+        subtree_ = tree2tex(subtree)
+
+    if subtree_need_parenthesis:
+        return f"({subtree_})"
+    return subtree_
+
+
 OPERATOR2TEX = {
     "+": plus2tex,
     "-": minus2tex,