Fix circular imports

src/andromede/expression/copy.py

@@ -11,56 +11,49 @@
 # This file is part of the Antares project.
 
 from dataclasses import dataclass
-from typing import List, Union, cast
+from typing import List, cast
 
-from .expression import (
-    AdditionNode,
+from .expression_efficient import (
     ComparisonNode,
     ComponentParameterNode,
-    ComponentVariableNode,
-    DivisionNode,
-    ExpressionNode,
+    ExpressionNodeEfficient,
     ExpressionRange,
     InstancesTimeIndex,
     LiteralNode,
-    MultiplicationNode,
-    NegationNode,
     ParameterNode,
     PortFieldAggregatorNode,
     PortFieldNode,
     ScenarioOperatorNode,
-    SubstractionNode,
     TimeAggregatorNode,
     TimeOperatorNode,
-    VariableNode,
 )
-from .visitor import ExpressionVisitor, ExpressionVisitorOperations, T, visit
+from .visitor import ExpressionVisitorOperations, visit
 
 
 @dataclass(frozen=True)
-class CopyVisitor(ExpressionVisitorOperations[ExpressionNode]):
+class CopyVisitor(ExpressionVisitorOperations[ExpressionNodeEfficient]):
     """
     Simply copies the whole AST.
     """
 
-    def literal(self, node: LiteralNode) -> ExpressionNode:
+    def literal(self, node: LiteralNode) -> ExpressionNodeEfficient:
         return LiteralNode(node.value)
 
-    def comparison(self, node: ComparisonNode) -> ExpressionNode:
+    def comparison(self, node: ComparisonNode) -> ExpressionNodeEfficient:
         return ComparisonNode(
             visit(node.left, self), visit(node.right, self), node.comparator
         )
 
-    def variable(self, node: VariableNode) -> ExpressionNode:
-        return VariableNode(node.name)
+    # def variable(self, node: VariableNode) -> ExpressionNodeEfficient:
+    #     return VariableNode(node.name)
 
-    def parameter(self, node: ParameterNode) -> ExpressionNode:
+    def parameter(self, node: ParameterNode) -> ExpressionNodeEfficient:
         return ParameterNode(node.name)
 
-    def comp_variable(self, node: ComponentVariableNode) -> ExpressionNode:
-        return ComponentVariableNode(node.component_id, node.name)
+    # def comp_variable(self, node: ComponentVariableNode) -> ExpressionNodeEfficient:
+    #     return ComponentVariableNode(node.component_id, node.name)
 
-    def comp_parameter(self, node: ComponentParameterNode) -> ExpressionNode:
+    def comp_parameter(self, node: ComponentParameterNode) -> ExpressionNodeEfficient:
         return ComponentParameterNode(node.component_id, node.name)
 
     def copy_expression_range(
@@ -69,9 +62,11 @@ def copy_expression_range(
         return ExpressionRange(
             start=visit(expression_range.start, self),
             stop=visit(expression_range.stop, self),
-            step=visit(expression_range.step, self)
-            if expression_range.step is not None
-            else None,
+            step=(
+                visit(expression_range.step, self)
+                if expression_range.step is not None
+                else None
+            ),
         )
 
     def copy_instances_index(
@@ -81,30 +76,32 @@ def copy_instances_index(
         if isinstance(expressions, ExpressionRange):
             return InstancesTimeIndex(self.copy_expression_range(expressions))
         if isinstance(expressions, list):
-            expressions_list = cast(List[ExpressionNode], expressions)
+            expressions_list = cast(List[ExpressionNodeEfficient], expressions)
             copy = [visit(e, self) for e in expressions_list]
             return InstancesTimeIndex(copy)
         raise ValueError("Unexpected type in instances index")
 
-    def time_operator(self, node: TimeOperatorNode) -> ExpressionNode:
+    def time_operator(self, node: TimeOperatorNode) -> ExpressionNodeEfficient:
         return TimeOperatorNode(
             visit(node.operand, self),
             node.name,
             self.copy_instances_index(node.instances_index),
         )
 
-    def time_aggregator(self, node: TimeAggregatorNode) -> ExpressionNode:
+    def time_aggregator(self, node: TimeAggregatorNode) -> ExpressionNodeEfficient:
         return TimeAggregatorNode(visit(node.operand, self), node.name, node.stay_roll)
 
-    def scenario_operator(self, node: ScenarioOperatorNode) -> ExpressionNode:
+    def scenario_operator(self, node: ScenarioOperatorNode) -> ExpressionNodeEfficient:
         return ScenarioOperatorNode(visit(node.operand, self), node.name)
 
-    def port_field(self, node: PortFieldNode) -> ExpressionNode:
+    def port_field(self, node: PortFieldNode) -> ExpressionNodeEfficient:
         return PortFieldNode(node.port_name, node.field_name)
 
-    def port_field_aggregator(self, node: PortFieldAggregatorNode) -> ExpressionNode:
+    def port_field_aggregator(
+        self, node: PortFieldAggregatorNode
+    ) -> ExpressionNodeEfficient:
         return PortFieldAggregatorNode(visit(node.operand, self), node.aggregator)
 
 
-def copy_expression(expression: ExpressionNode) -> ExpressionNode:
+def copy_expression(expression: ExpressionNodeEfficient) -> ExpressionNodeEfficient:
     return visit(expression, CopyVisitor())

src/andromede/expression/degree.py

@@ -11,28 +11,26 @@
 # This file is part of the Antares project.
 
 import andromede.expression.scenario_operator
-from andromede.expression.expression import (
-    ComponentParameterNode,
-    ComponentVariableNode,
-    PortFieldAggregatorNode,
-    PortFieldNode,
-    TimeOperatorNode,
-)
-
-from .expression import (
+from andromede.expression.expression_efficient import (
     AdditionNode,
     ComparisonNode,
+    ComponentParameterNode,
     DivisionNode,
-    ExpressionNode,
+    ExpressionNodeEfficient,
     LiteralNode,
     MultiplicationNode,
     NegationNode,
     ParameterNode,
+    PortFieldAggregatorNode,
+    PortFieldNode,
     ScenarioOperatorNode,
     SubstractionNode,
+    TimeAggregatorName,
     TimeAggregatorNode,
-    VariableNode,
+    TimeOperatorName,
+    TimeOperatorNode,
 )
+
 from .visitor import ExpressionVisitor, T, visit
 
 
@@ -66,26 +64,26 @@ def division(self, node: DivisionNode) -> int:
     def comparison(self, node: ComparisonNode) -> int:
         return max(visit(node.left, self), visit(node.right, self))
 
-    def variable(self, node: VariableNode) -> int:
-        return 1
+    # def variable(self, node: VariableNode) -> int:
+    #     return 1
 
     def parameter(self, node: ParameterNode) -> int:
         return 0
 
-    def comp_variable(self, node: ComponentVariableNode) -> int:
-        return 1
+    # def comp_variable(self, node: ComponentVariableNode) -> int:
+    #     return 1
 
     def comp_parameter(self, node: ComponentParameterNode) -> int:
         return 0
 
     def time_operator(self, node: TimeOperatorNode) -> int:
-        if node.name in ["TimeShift", "TimeEvaluation"]:
+        if node.name in [TimeOperatorName.SHIFT, TimeOperatorName.EVALUATION]:
             return visit(node.operand, self)
         else:
             return NotImplemented
 
     def time_aggregator(self, node: TimeAggregatorNode) -> int:
-        if node.name in ["TimeSum"]:
+        if node.name in [TimeAggregatorName.TIME_SUM]:
             return visit(node.operand, self)
         else:
             return NotImplemented
@@ -104,18 +102,18 @@ def port_field_aggregator(self, node: PortFieldAggregatorNode) -> int:
         return visit(node.operand, self)
 
 
-def compute_degree(expression: ExpressionNode) -> int:
+def compute_degree(expression: ExpressionNodeEfficient) -> int:
     return visit(expression, ExpressionDegreeVisitor())
 
 
-def is_constant(expr: ExpressionNode) -> bool:
+def is_constant(expr: ExpressionNodeEfficient) -> bool:
     """
     True if the expression has no variable.
     """
     return compute_degree(expr) == 0
 
 
-def is_linear(expr: ExpressionNode) -> bool:
+def is_linear(expr: ExpressionNodeEfficient) -> bool:
     """
     True if the expression is linear with respect to variables.
     """

src/andromede/expression/equality.py

@@ -99,7 +99,9 @@ def visit(
         #     return self.variable(left, right)
         if isinstance(left, ParameterNode) and isinstance(right, ParameterNode):
             return self.parameter(left, right)
-        if isinstance(left, ComponentParameterNode) and isinstance(right, ComponentParameterNode):
+        if isinstance(left, ComponentParameterNode) and isinstance(
+            right, ComponentParameterNode
+        ):
             return self.comp_parameter(left, right)
         if isinstance(left, TimeOperatorNode) and isinstance(right, TimeOperatorNode):
             return self.time_operator(left, right)
@@ -154,8 +156,10 @@ def comparison(self, left: ComparisonNode, right: ComparisonNode) -> bool:
 
     def parameter(self, left: ParameterNode, right: ParameterNode) -> bool:
         return left.name == right.name
-
-    def comp_parameter(self, left: ComponentParameterNode, right: ComponentParameterNode) -> bool:
+
+    def comp_parameter(
+        self, left: ComponentParameterNode, right: ComponentParameterNode
+    ) -> bool:
         return left.component_id == right.component_id and left.name == right.name
 
     def expression_range(self, left: ExpressionRange, right: ExpressionRange) -> bool:

src/andromede/expression/evaluate.py

@@ -14,28 +14,20 @@
 from dataclasses import dataclass, field
 from typing import Dict
 
-from andromede.expression.expression import (
-    ComponentParameterNode,
-    ComponentVariableNode,
-    PortFieldAggregatorNode,
-    PortFieldNode,
-    TimeOperatorNode,
-)
-
-from .expression import (
-    AdditionNode,
+from andromede.expression.expression import VariableNode
+from andromede.expression.expression_efficient import (
     ComparisonNode,
-    DivisionNode,
-    ExpressionNode,
+    ComponentParameterNode,
+    ExpressionNodeEfficient,
     LiteralNode,
-    MultiplicationNode,
-    NegationNode,
     ParameterNode,
+    PortFieldAggregatorNode,
+    PortFieldNode,
     ScenarioOperatorNode,
-    SubstractionNode,
     TimeAggregatorNode,
-    VariableNode,
+    TimeOperatorNode,
 )
+
 from .visitor import ExpressionVisitor, ExpressionVisitorOperations, T, visit
 
 
@@ -117,8 +109,8 @@ def parameter(self, node: ParameterNode) -> float:
     def comp_parameter(self, node: ComponentParameterNode) -> float:
         return self.context.get_component_parameter_value(node.component_id, node.name)
 
-    def comp_variable(self, node: ComponentVariableNode) -> float:
-        return self.context.get_component_variable_value(node.component_id, node.name)
+    # def comp_variable(self, node: ComponentVariableNode) -> float:
+    #     return self.context.get_component_variable_value(node.component_id, node.name)
 
     def time_operator(self, node: TimeOperatorNode) -> float:
         raise NotImplementedError()
@@ -136,7 +128,9 @@ def port_field_aggregator(self, node: PortFieldAggregatorNode) -> float:
         raise NotImplementedError()
 
 
-def evaluate(expression: ExpressionNode, value_provider: ValueProvider) -> float:
+def evaluate(
+    expression: ExpressionNodeEfficient, value_provider: ValueProvider
+) -> float:
     return visit(expression, EvaluationVisitor(value_provider))