@@ -10,39 +10,45 @@ def __init__(
1010 self ,
1111 message : str = "Expression resolver exception" ,
1212 expression : Expression | None = None ,
13+ parent : Exception | None = None ,
1314 ):
14- super ().__init__ (f"{ message } { expression } )
15+ super ().__init__ (f"{ message } { expression } { parent } )
16+ self ._parent = parent
1517
1618
1719class ExpressionResolverNotResolvable (ExpressionResolverException ):
1820 def __init__ (
1921 self ,
2022 message : str = "Expression is not resolvable" ,
2123 expression : Expression | None = None ,
24+ parent : Exception | None = None ,
2225 ):
23- super ().__init__ (message , expression = expression )
26+ super ().__init__ (message , expression = expression , parent = parent )
2427
2528
2629class ExpressionResolverMaybeNotResolvable (ExpressionResolverException ):
2730 def __init__ (
2831 self ,
2932 message : str = "Expression is maybe not resolvable" ,
3033 expression : Expression | None = None ,
34+ parent : Exception | None = None ,
3135 ):
32- super ().__init__ (message , expression = expression )
36+ super ().__init__ (message , expression = expression , parent = parent )
3337
3438
3539class ExpressionResolver :
3640 def __init__ (self , validator : ExpressionValidator , number_factory : NumberFactory ):
3741 self ._validator = validator
3842 self ._number_factory = number_factory
39- pass
43+ self . _maximum_resolve_time_sec = 0.1
4044
41- def _fly_back (self , expression : Expression ):
42- self ._number_factory .fly_back (expression .operand1 )
43- self ._number_factory .fly_back (expression .operand2 )
44- self ._number_factory .fly_back (expression .result )
45- pass
45+ def _fly_back (self , base : Expression , result : Expression ):
46+ if base .operand1 is None :
47+ self ._number_factory .fly_back (result .operand1 )
48+ if base .operand2 is None :
49+ self ._number_factory .fly_back (result .operand2 )
50+ if base .result is None :
51+ self ._number_factory .fly_back (result .result )
4652
4753 def _fix_result (self , expression : Expression ):
4854 expression .operand1 = self ._number_factory .fix (expression .operand1 )
@@ -60,7 +66,7 @@ def _next_operator(self, expression: Expression) -> list[Operator]:
6066 def _resolve_result_is_none (self , expression : Expression ) -> Expression :
6167 start = time .time ()
6268 operators = self ._next_operator (expression )
63- while True :
69+ while time . time () - start < self . _maximum_resolve_time_sec :
6470 exp_result = expression .clone ()
6571 if exp_result .operator is None :
6672 try :
@@ -75,15 +81,27 @@ def _resolve_result_is_none(self, expression: Expression) -> Expression:
7581 exp_result .operand1 = self ._number_factory .next ()
7682 if exp_result .operand2 is None :
7783 if exp_result .operator == Operator .SUB :
78- exp_result .operand2 = self ._number_factory .next (
79- maximum = exp_result .operand1
80- )
84+ try :
85+ exp_result .operand2 = self ._number_factory .next (
86+ maximum = exp_result .operand1
87+ )
88+ except ValueError as e :
89+ raise ExpressionResolverNotResolvable (
90+ expression = expression , parent = e
91+ )
8192 elif exp_result .operator == Operator .DIV :
82- exp_result .operand2 = self ._number_factory .next (
83- maximum = exp_result .operand1 ,
84- dividable_by = exp_result .operand1 ,
85- zero_allowed = False ,
86- )
93+ try :
94+ exp_result .operand2 = self ._number_factory .next (
95+ maximum = exp_result .operand1 ,
96+ dividable_by = exp_result .operand1 ,
97+ zero_allowed = False ,
98+ )
99+ except ValueError as e :
100+ if expression .operator is None :
101+ continue
102+ raise ExpressionResolverNotResolvable (
103+ expression = expression , parent = e
104+ )
87105 else :
88106 exp_result .operand2 = self ._number_factory .next ()
89107 exp_result .result = self ._number_factory .fix (
@@ -95,15 +113,15 @@ def _resolve_result_is_none(self, expression: Expression) -> Expression:
95113 self ._check_result (expression , exp_result )
96114 if not self ._validator .validate (exp_result ):
97115 # TODO time or count limit
98- time_diff = time .time () - start
99- if time_diff > 1.0 :
100- raise ExpressionResolverMaybeNotResolvable (
101- message = f"Too slow: { time_diff :.1f} , expression = expression
102- )
103116 continue
104- self ._fly_back (exp_result )
117+ self ._fly_back (expression , exp_result )
105118 return exp_result
106119
120+ time_diff = time .time () - start
121+ raise ExpressionResolverMaybeNotResolvable (
122+ message = f"Too slow: { time_diff :.1f} , expression = expression
123+ )
124+
107125 def _resolve_only_operator_missing (self , expression : Expression ) -> Expression :
108126 if (
109127 expression .operand1 is None
@@ -133,13 +151,13 @@ def _resolve_only_operator_missing(self, expression: Expression) -> Expression:
133151 self ._check_result (expression , exp_result )
134152 if not self ._validator .validate (exp_result ):
135153 continue
136- self ._fly_back (exp_result )
154+ self ._fly_back (expression , exp_result )
137155 return exp_result
138156 raise ExpressionResolverNotResolvable (expression = expression )
139157
140158 def _resolve_result_is_available (self , expression : Expression ) -> Expression :
141159 start = time .time ()
142- while True :
160+ while time . time () - start < self . _maximum_resolve_time_sec :
143161 exp_calc = expression .clone ()
144162 exp_result = expression .clone ()
145163 exp_result .result = expression .result
@@ -174,11 +192,19 @@ def _resolve_result_is_available(self, expression: Expression) -> Expression:
174192 # ? * b = c -> c / b = a
175193 exp_calc .operator = Operator .DIV
176194 if not_has_operands :
177- exp_result .operand1 = exp_calc .operand1 = self ._number_factory .next (
178- dividable_by = exp_result .result ,
179- zero_allowed = False ,
180- )
181- print (exp_calc )
195+ try :
196+ exp_result .operand1 = exp_calc .operand1 = (
197+ self ._number_factory .next (
198+ dividable_by = exp_result .result ,
199+ zero_allowed = False ,
200+ )
201+ )
202+ except ValueError as e :
203+ if expression .operator is None :
204+ continue
205+ raise ExpressionResolverNotResolvable (
206+ expression = expression , parent = e
207+ )
182208 elif operator == Operator .DIV :
183209 # a / b = c
184210 if not_has_operands :
@@ -219,15 +245,15 @@ def _resolve_result_is_available(self, expression: Expression) -> Expression:
219245
220246 if not self ._validator .validate (exp_result ):
221247 # TODO time or count limit
222- time_diff = time .time () - start
223- if time_diff > 1.0 :
224- raise ExpressionResolverMaybeNotResolvable (
225- message = f"Too slow: { time_diff :.1f} , expression = expression
226- )
227248 continue
228- self ._fly_back (exp_result )
249+ self ._fly_back (expression , exp_result )
229250 return exp_result
230251
252+ time_diff = time .time () - start
253+ raise ExpressionResolverMaybeNotResolvable (
254+ message = f"Too slow: { time_diff :.1f} , expression = expression
255+ )
256+
231257 def resolve (self , expression : Expression ) -> Expression | None :
232258 start_time = time .time ()
233259 try :
0 commit comments