def confprol_random():
element = random.randint(0,21)
if element in [0,1]:
return BasicExpression(ConfprolObject(bool(element)),"random()",ValueType.BOOLEAN)
elif element in range(2,6):
value = random.randint(-10000000000000,10000000000000)
return BasicExpression(ConfprolObject(value),"random()",ValueType.NUMBER)
elif element in range(6,10):
value = random.uniform(-10000000000000, 10000000000000)
return BasicExpression(ConfprolObject(value), "random()", ValueType.NUMBER)
elif element == 10:
return confprol_none
elif element == 1:
return TrueExceptFridays()
elif element == 12:
return MillionToOneChance()
elif element in range(13,17):
axis = random.randint(0,1)
value = random.randint(0,1)
return QuanticBoolean(QuanticAxis(axis),bool(value))
elif element in range(17,19):
list_ = ListExpression(ConfprolObject([]),"random()")
element = random.randint(0, 4)
while element !=0:
list_.append(confprol_random())
element = random.randint(0, 4)
return list_
else:
length = random.randint(0, 100)
value = ''.join(random.choices(string.ascii_uppercase + string.digits + string.ascii_lowercase,k=length))
return StringExpression(ConfprolObject(value),"random()")
def confprol_range(start_expr,end_expr):
start = start_expr.value
end = end_expr.value
if not type(start)==int:
raise ConfprolValueError(f"The start value in range() must be an integer.")
if not type(end)==int:
raise ConfprolValueError(f"The end value in range() must be an integer.")
range_ = range(start,end)
list_ = map(lambda x: BasicExpression(ConfprolObject(x),x,ValueType.NUMBER),range_)
return ListExpression(ConfprolObject(list_),f"range({start},{end})")
def load_string(self, text: str):
text = text[1:len(text) - 1]
string = string_algorithm(text)
return StringExpression(ConfprolObject(string), text)
def div(expr1: BasicExpression, expr2: BasicExpression):
name = f"{expr1.name} / {expr2.name}"
if expr2.value == 0:
raise DivisionByZero()
value = expr1.value / expr2.value
return BasicExpression(ConfprolObject(value), name, ValueType.NUMBER)
def has_attribute(args):
expr = args[0]
attr = args[1].value
if type(attr)!= str:
raise ConfprolValueError("The second argument of the function 'has_attribute' must be a string")
return BasicExpression(ConfprolObject(expr.has_attribute(attr)),f"has_attribute({expr}{attr})",ValueType.BOOLEAN)
def test_equal_number_boolean(self):
expr = TypeOperations.equals(self.number1, self.boolean_true)
self.assertFalse(expr.value)
self.assertEqual("3 := True", expr.name)
zero = BasicExpression(ConfprolObject(0), 0, ValueType.NUMBER)
expr2 = TypeOperations.equals(self.boolean_false, zero)
self.assertTrue(expr2.value)
self.assertEqual("False := 0", expr2.name)
def test_equal_number_string(self):
three_str = BasicExpression(ConfprolObject("3"), "3", ValueType.STRING)
expr = TypeOperations.equals(self.number1, three_str)
self.assertFalse(expr.value)
self.assertEqual("3 := 3", expr.name)
expr2 = TypeOperations.equals(self.string1, self.number2)
self.assertFalse(expr2.value)
self.assertEqual("firstString := 5", expr2.name)
def evaluate(self, axis: QuanticAxis):
if axis != self.object.axis:
self.object.axis = axis
value = random.randint(0, 9)
if value >= 5:
self.object.value = True
else:
self.object.value = False
return BasicExpression(ConfprolObject(self.object.value),
f"evalX{self}", ValueType.BOOLEAN)
def setUp(self):
self.number1 = BasicExpression(ConfprolObject(3), 3, ValueType.NUMBER)
self.number2 = BasicExpression(ConfprolObject(5), 5, ValueType.NUMBER)
self.boolean_true = BasicExpression(ConfprolObject(True), True,
ValueType.BOOLEAN)
self.boolean_false = BasicExpression(ConfprolObject(False), False,
ValueType.BOOLEAN)
self.string1 = BasicExpression(ConfprolObject("firstString"),
"firstString", ValueType.STRING)
self.string2 = BasicExpression(ConfprolObject("secondString"),
"secondString", ValueType.STRING)
def __init__(self, object=None):
if object is None:
object = ConfprolObject(None)
super(MillionToOneChance, self).__init__(object, "MillionToOneChance",
ValueType.BOOLEAN)
def __init__(self, object=None):
if object is None:
object = ConfprolObject(None)
super(TrueExceptFridays, self).__init__(object, "TrueExceptFridays",
ValueType.BOOLEAN)
def to_string(expression):
value = str(expression)
return StringExpression(ConfprolObject(value),value)
def get_input(message):
value = input(message)
input_ = string_algorithm(value)
return StringExpression(ConfprolObject(input_),input_)
def length_function(expr: List[BasicExpression]):
expr = expr[0]
value = len(expr.value)
return BasicExpression(ConfprolObject(value), f"length({expr.name})",
ValueType.NUMBER)
def load_list(self, values):
expression_names = list(map(lambda expr: expr.name, values))
name = "[" + ",".join(expression_names) + "]"
return ListExpression(ConfprolObject(values), name)
def to_integer(expression):
int_value = int(expression.value)
return BasicExpression(ConfprolObject(int_value), f"int({expression.value})", ValueType.NUMBER)
def to_integer(expression):
try:
int_value = int(float(expression.value)) # First to float to allow strings like "3.2"
return BasicExpression(ConfprolObject(int_value), f"int({expression.value})", ValueType.NUMBER)
except ValueError:
raise ConfprolValueError(f"The string/variable '{expression.name}' can't be transformed to integer.")
def load_boolean(self, boolean: bool):
return BasicExpression(ConfprolObject(boolean), str(boolean),
ValueType.BOOLEAN)
def __init__(self, name):
super(ObjectExpression, self).__init__(ConfprolObject(object()), name,
ValueType.OBJECT)
def load_number(self, number: int):
a = BasicExpression(ConfprolObject(number), str(number),
ValueType.NUMBER)
return a
def equals(expr1: BasicExpression, expr2: BasicExpression):
name = f"{expr1.name} := {expr2.name}"
value = expr1.value == expr2.value
return BasicExpression(ConfprolObject(value), name, ValueType.BOOLEAN)
def minus(expr1: BasicExpression, expr2: BasicExpression):
name = f"{expr1.name} - {expr2.name}"
value = expr1.value - expr2.value
return BasicExpression(ConfprolObject(value), name, ValueType.NUMBER)
def test_div_by_0(self):
zero = BasicExpression(ConfprolObject(0), 0, ValueType.NUMBER)
with self.assertRaises(DivisionByZero):
TypeOperations.div(self.number1, zero)
def to_float(expression):
float_value = float(expression.value)
return BasicExpression(ConfprolObject(float_value), f"float({expression.value})", ValueType.NUMBER)
def load_float(self, float: float):
return BasicExpression(ConfprolObject(float), str(float),
ValueType.NUMBER)
def to_float(expression):
try:
float_value = float(expression.value)
return BasicExpression(ConfprolObject(float_value), f"int({expression.value})", ValueType.NUMBER)
except ValueError:
raise ConfprolValueError(f"The string/variable '{expression.name}' can't be transformed to float.")
from .basic_expression import BasicExpression from type import ValueType from expressions.objects.confprol_object import ConfprolObject confprol_none = BasicExpression(ConfprolObject(None), None, ValueType.NONE)
def plus(expr1: BasicExpression, expr2: BasicExpression):
name = f"{expr1.name} + {expr2.name}"
value = str(expr1.value) + str(expr2.value)
return StringExpression(ConfprolObject(value), name)