enh: performance optimalisation

kamarton · kamarton · commit aaa7288f7294 · 2024-04-12T23:02:10.000+02:00
enh: add more test
fix: resolver test
enh: simplify code
diff --git a/crossmath.py b/crossmath.py
@@ -40,7 +40,12 @@ def clear(self):
 
 
 class CrossMath:
-    def __init__(self, exp_map: ExpressionMap, number_factory: NumberFactory, expression_resolver : ExpressionResolver):
+    def __init__(
+        self,
+        exp_map: ExpressionMap,
+        number_factory: NumberFactory,
+        expression_resolver: ExpressionResolver,
+    ):
         self._map = exp_map
         self._number_factory = number_factory
         self._expression_resolver = expression_resolver
@@ -159,7 +164,7 @@ def generate(self):
                 direction, _x, _y, values = desc
                 try:
                     expression = self._expression_resolver.resolve(
-                        Expression.from_values(values)
+                        Expression.from_list(values)
                     )
                 except ExpressionResolverException as e:
                     print(e)
diff --git a/expression.py b/expression.py
@@ -1,9 +1,7 @@
 from enum import Enum
 from typing import TypeVar
 
-import pandas
-
-from number_factory import NumberFactory
+from number_helper import number_is_zero, number_is_equal
 
 Exp = TypeVar("Exp", bound="Expression")
 Opr = TypeVar("Opr", bound="Operator")
@@ -47,20 +45,7 @@ def is_empty(self) -> bool:
         )
 
     @staticmethod
-    def from_str(exp: str) -> Exp:
-        values = exp.split()
-        result = []
-        for i in range(0, len(values)):
-            if values[i] == "?":
-                result.append(None)
-            elif i % 2 == 0:
-                result.append(float(values[i]))
-            else:
-                result.append(Operator(values[i]))
-        return Expression.from_values(result)
-
-    @staticmethod
-    def from_values(values: list) -> Exp:
+    def from_list(values: list) -> Exp:
         if len(values) not in Expression.SUPPORTED_LENGTHS:
             raise ValueError(
                 f"Invalid values ({len(values)} not in {Expression.SUPPORTED_LENGTHS})"
@@ -99,15 +84,39 @@ def __str__(self):
     def get_length(self) -> int:
         return self._length
 
+    def is_match(self, exp: Exp, none_allowed: bool = True) -> bool:
+        if not none_allowed:
+            raise ValueError("Not supported")
+        return (
+            (
+                self.operand1 is None
+                or exp.operand1 is None
+                or number_is_equal(self.operand1, exp.operand1)
+            )
+            and (
+                self.operator is None
+                or exp.operator is None
+                or self.operator == exp.operator
+            )
+            and (
+                self.operand2 is None
+                or exp.operand2 is None
+                or number_is_equal(self.operand2, exp.operand2)
+            )
+            and (
+                self.result is None
+                or exp.result is None
+                or number_is_equal(self.result, exp.result)
+            )
+        )
+
 
 class ExpressionValidator:
     def __init__(
         self,
-        number_factory: NumberFactory,
         minimum: float = 0.0,
         maximum: float = 100.0,
     ):
-        self._number_factory: NumberFactory = number_factory
         self._minimum: float = minimum
         self._maximum: float = maximum
 
@@ -139,11 +148,9 @@ def validate(self, expression: Expression) -> bool:
             return False
         if not self._check_range(expression.result):
             return False
-        if expression.operator == Operator.DIV and NumberFactory.is_zero(
-            expression.operand2
-        ):
+        if expression.operator == Operator.DIV and number_is_zero(expression.operand2):
             return False
-        return NumberFactory.is_equal(
+        return number_is_equal(
             eval(f"{expression.operand1} {expression.operator} {expression.operand2}"),
             expression.result,
         )
diff --git a/expression_resolver.py b/expression_resolver.py
@@ -1,8 +1,8 @@
 import random
-import time
 
 from expression import Expression, ExpressionValidator, Operator
 from number_factory import NumberFactory
+from number_helper import number_is_zero, number_is_equal
 
 
 class ExpressionResolverException(Exception):
@@ -40,7 +40,7 @@ class ExpressionResolver:
     def __init__(self, validator: ExpressionValidator, number_factory: NumberFactory):
         self._validator = validator
         self._number_factory = number_factory
-        self._maximum_resolve_time_sec = 0.1
+        self._resolve_maximum_loop_count = 8
 
     def _fly_back(self, base: Expression, result: Expression):
         if base.operand1 is None:
@@ -56,24 +56,26 @@ def _fix_result(self, expression: Expression):
         expression.result = self._number_factory.fix(expression.result)
 
     def _next_operator(self, expression: Expression) -> list[Operator]:
+        operators_allowed = Operator.get_operators_without_eq()
+        if number_is_zero(expression.operand2):
+            # ? ? 0 = c
+            operators_allowed.remove(Operator.DIV)
         if expression.operand1 is None or expression.operand2 is None:
-            yield random.choice(Operator.get_operators_without_eq())
-        operators = Operator.get_operators_without_eq()
-        random.shuffle(operators)
-        for operator in operators:
+            yield random.choice(operators_allowed)
+        random.shuffle(operators_allowed)
+        for operator in operators_allowed:
             yield operator
 
     def _resolve_result_is_none(self, expression: Expression) -> Expression:
-        start = time.time()
         operators = self._next_operator(expression)
-        while time.time() - start < self._maximum_resolve_time_sec:
+        for _ in range(self._resolve_maximum_loop_count):
             exp_result = expression.clone()
             if exp_result.operator is None:
                 try:
                     exp_result.operator = next(operators)
                 except StopIteration:
                     raise ExpressionResolverNotResolvable(expression=expression)
-            if exp_result.operator == Operator.DIV and NumberFactory.is_zero(
+            if exp_result.operator == Operator.DIV and number_is_zero(
                 exp_result.operand2
             ):
                 continue
@@ -104,22 +106,20 @@ def _resolve_result_is_none(self, expression: Expression) -> Expression:
                         )
                 else:
                     exp_result.operand2 = self._number_factory.next()
-            exp_result.result = self._number_factory.fix(
-                eval(
-                    f"{exp_result.operand1} {exp_result.operator} {exp_result.operand2}"
-                )
+            exp_result.result = eval(
+                f"{exp_result.operand1} {exp_result.operator} {exp_result.operand2}"
             )
             self._fix_result(exp_result)
-            self._check_result(expression, exp_result)
+            if not expression.is_match(exp_result):
+                raise RuntimeError(f"Result is not match: {expression} vs {exp_result}")
             if not self._validator.validate(exp_result):
-                # TODO time or count limit
                 continue
             self._fly_back(expression, exp_result)
             return exp_result
 
-        time_diff = time.time() - start
         raise ExpressionResolverMaybeNotResolvable(
-            message=f"Too slow: {time_diff:.1f}s", expression=expression
+            message=f"Try count is reached ({self._resolve_maximum_loop_count})",
+            expression=expression,
         )
 
     def _resolve_only_operator_missing(self, expression: Expression) -> Expression:
@@ -135,29 +135,28 @@ def _resolve_only_operator_missing(self, expression: Expression) -> Expression:
         operators = Operator.get_operators_without_eq()
         random.shuffle(operators)
         for operator in operators:
-            if operator == Operator.DIV and NumberFactory.is_zero(expression.operand2):
+            if operator == Operator.DIV and number_is_zero(expression.operand2):
                 # zero division
                 continue
             exp_result = expression.clone()
             exp_result.operator = operator
-            exp_result.result = self._number_factory.fix(
-                eval(
-                    f"{exp_result.operand1} {exp_result.operator} {exp_result.operand2}"
-                )
+            exp_result.result = eval(
+                f"{exp_result.operand1} {exp_result.operator} {exp_result.operand2}"
             )
-            if not NumberFactory.is_equal(exp_result.result, expression.result):
+
+            if not number_is_equal(exp_result.result, expression.result):
                 continue
             self._fix_result(exp_result)
-            self._check_result(expression, exp_result)
+            if not expression.is_match(exp_result):
+                raise RuntimeError(f"Result is not match: {expression} vs {exp_result}")
             if not self._validator.validate(exp_result):
                 continue
             self._fly_back(expression, exp_result)
             return exp_result
         raise ExpressionResolverNotResolvable(expression=expression)
 
     def _resolve_result_is_available(self, expression: Expression) -> Expression:
-        start = time.time()
-        while time.time() - start < self._maximum_resolve_time_sec:
+        for _ in range(self._resolve_maximum_loop_count):
             exp_calc = expression.clone()
             exp_result = expression.clone()
             exp_result.result = expression.result
@@ -241,47 +240,27 @@ def _resolve_result_is_available(self, expression: Expression) -> Expression:
                 )
             else:
                 raise RuntimeError("Invalid state: only one operand is missing")
-            self._check_result(expression, exp_result)
 
+            if not expression.is_match(exp_result):
+                raise RuntimeError(f"Result is not match: {expression} vs {exp_result}")
             if not self._validator.validate(exp_result):
                 # TODO time or count limit
                 continue
             self._fly_back(expression, exp_result)
             return exp_result
 
-        time_diff = time.time() - start
         raise ExpressionResolverMaybeNotResolvable(
-            message=f"Too slow: {time_diff:.1f}s", expression=expression
+            message=f"Try count is reached ({self._resolve_maximum_loop_count})",
+            expression=expression,
         )
 
     def resolve(self, expression: Expression) -> Expression | None:
-        start_time = time.time()
-        try:
-            if expression.result is None:
-                return self._resolve_result_is_none(expression)
-            if expression.operand1 is not None and expression.operand2 is not None:
-                return self._resolve_only_operator_missing(expression)
-            return self._resolve_result_is_available(expression)
-        finally:
-            end_time = time.time()
-            diff = end_time - start_time
-            if diff > 0.01:
-                print(f"ExpressionResolver.resolve: {diff:.2f} seconds")
-
-    def _check_result(self, expression: Expression, result: Expression):
-        if expression.operand1 is not None:
-            if not NumberFactory.is_equal(expression.operand1, result.operand1):
-                raise RuntimeError(f"Invalid operand1: {expression} -> {result}")
-        if expression.operand2 is not None:
-            if not NumberFactory.is_equal(expression.operand2, result.operand2):
-                raise RuntimeError(f"Invalid operand2: {expression} -> {result}")
-        if expression.result is not None:
-            if not NumberFactory.is_equal(expression.result, result.result):
-                raise RuntimeError(f"Invalid result: {expression} -> {result}")
-        if expression.operator is not None:
-            if expression.operator != result.operator:
-                raise RuntimeError(f"Invalid operator: {expression} -> {result}")
+        if expression.result is None:
+            return self._resolve_result_is_none(expression)
+        if expression.operand1 is not None and expression.operand2 is not None:
+            return self._resolve_only_operator_missing(expression)
+        return self._resolve_result_is_available(expression)
 
     @staticmethod
     def is_zero_division(operator: Operator, operand2: float) -> bool:
-        return operator == Operator.DIV and NumberFactory.is_zero(operand2)
+        return operator == Operator.DIV and number_is_zero(operand2)
diff --git a/main.py b/main.py
@@ -9,7 +9,7 @@
 HEIGHT = int(os.environ.get("HEIGHT", 30))
 NUMBER_FACTORY_MIN = float(os.environ.get("NUMBER_FACTORY_MIN", -20.0))
 NUMBER_FACTORY_MAX = float(os.environ.get("NUMBER_FACTORY_MAX", 20.0))
-NUMBER_FACTORY_STEP = float(os.environ.get("NUMBER_FACTORY_STEP", 0.5))
+NUMBER_FACTORY_STEP = float(os.environ.get("NUMBER_FACTORY_STEP", 0.1))
 
 if __name__ == "__main__":
     exp_map = ExpressionMap(width=WIDTH, height=HEIGHT)
@@ -19,9 +19,7 @@
         step=NUMBER_FACTORY_STEP,
     )
     resolver = ExpressionResolver(
-        validator=ExpressionValidator(
-            number_factory=number_factory, minimum=-100, maximum=100
-        ),
+        validator=ExpressionValidator(minimum=-100, maximum=100),
         number_factory=number_factory,
     )
     cross_math = CrossMath(
diff --git a/number_factory.py b/number_factory.py
@@ -2,6 +2,8 @@
 import random
 import time
 
+from number_helper import number_is_zero, number_is_equal, number_fix
+
 
 class RandomGenerator:
     def __init__(self, seed: int = None):
@@ -61,7 +63,7 @@ def next(
         if minimum > maximum:
             raise ValueError(f"Minimum is greater than maximum: {minimum} > {maximum}")
         if dividable_by is not None:
-            if NumberFactory.is_zero(dividable_by):
+            if number_is_zero(dividable_by):
                 dividable_by = self._step
             else:
                 dividable_by = abs(dividable_by)
@@ -95,39 +97,25 @@ def next(
             random_in_range = self._random_generator.next_int(range_int)
             value = minimum_start + random_in_range * dividable_by
             value_fixed = self.fix(value, dividable_by)
-            if not NumberFactory.is_equal(value, self.fix(value, dividable_by)):
+            if not number_is_equal(value, self.fix(value, dividable_by)):
                 raise RuntimeError(
                     f"Value is not equal to fixed value: {value} vs {value_fixed}"
                 )
-            if value < minimum_start:
+            if number_fix(value) < number_fix(minimum_start):
                 raise RuntimeError(
                     f"Value is less than minimum: {value} < {minimum_start} minimum={minimum}"
                 )
-            if value > maximum_end:
+            if number_fix(value) > number_fix(maximum_end):
                 raise RuntimeError(
                     f"Value is greater than maximum: {value} > {maximum_end} maximum={maximum}"
                 )
-            if not zero_allowed and NumberFactory.is_zero(value):
+            if not zero_allowed and number_is_zero(value):
                 continue
             return self.fix(value)
         raise RuntimeError(
             f"Cannot find random value in {max_runtime_sec} second, paramters: minimum={minimum}, maximum={maximum}, dividable_by={dividable_by}, zero_allowed={zero_allowed}"
         )
 
-    @staticmethod
-    def is_zero(value: float | None):
-        if value is None:
-            return False
-        return abs(0.0 - value) < 1e-6
-
-    @staticmethod
-    def is_equal(value1: float | None, value2: float | None) -> bool:
-        if value1 is None and value2 is None:
-            return True
-        if value1 is None or value2 is None:
-            return False
-        return NumberFactory.is_zero(value1 - value2)
-
     def format(self, value: float | None, decimals: int | None = None) -> str:
         if value is None:
             return ""
@@ -142,7 +130,7 @@ def fix(self, value: float, step: float | None = None) -> float:
             raise ValueError(
                 f"Step must be greater than or equal to the factory step: {self._step} vs {step}"
             )
-        return round(round(value / step) * step, self._decimals)
+        return float(round(round(value / step) * step, self._decimals))
 
     def fly_back(self, value: float):
         str_value = self.format(value)
diff --git a/number_helper.py b/number_helper.py
@@ -0,0 +1,18 @@
+def number_is_zero(value: float | None):
+    if value is None:
+        return False
+    return abs(0.0 - value) < 1e-6
+
+
+def number_is_equal(value1: float | None, value2: float | None) -> bool:
+    if value1 is None and value2 is None:
+        return True
+    if value1 is None or value2 is None:
+        return False
+    return number_is_zero(value1 - value2)
+
+
+def number_fix(value: float | None) -> float | None:
+    if value is None:
+        return None
+    return round(value, 6)
diff --git a/test_expression_resolver.py b/test_expression_resolver.py
diff --git a/test_number_factory.py b/test_number_factory.py
diff --git a/test_number_helper.py b/test_number_helper.py
