literaly wrote entire mutation engine in only 3 hours

Author: cassanof

engine.py

@@ -1,10 +1,11 @@
 from numpy import random
+
 # Mutation operators
 # AOR: Arithmetic Operator Replacement: a + b -> a - b
 # LCR: Logical Connector Replacement: a and b -> a or b
 # ROR: Relational Operator Replacement: a > b -> a < b
-# UOI: Unary Operator Insertion: a -> not a (only in conditionals)
-# SBR: Statement Block Replacement: stmt -> 0
+# UOI: Unary Operator Insertion: b -> not b, i -> i + 1
+# SBR: Statement Block Replacement: stmt -> 0 TODO
 
 from typing import Literal, Callable, Any
 
@@ -27,29 +28,122 @@ def convert_to_add(self, node):
     def convert_to_sub(self, node):
         raise NotImplementedError
 
+    def convert_to_binop_a(self, node):
+        raise NotImplementedError
+
+    def convert_to_binop_b(self, node):
+        raise NotImplementedError
+
+    def convert_to_boolop_a(self, node):
+        raise NotImplementedError
+
+    def convert_to_boolop_b(self, node):
+        raise NotImplementedError
+
+    def convert_to_and(self, node):
+        raise NotImplementedError
+
+    def convert_to_or(self, node):
+        raise NotImplementedError
+
+    def convert_to_true(self, node):
+        raise NotImplementedError
+
+    def convert_to_false(self, node):
+        raise NotImplementedError
+
+    def convert_to_gt(self, node):
+        raise NotImplementedError
+
+    def convert_to_lt(self, node):
+        raise NotImplementedError
+
+    def convert_to_gte(self, node):
+        raise NotImplementedError
+
+    def convert_to_lte(self, node):
+        raise NotImplementedError
+
+    def convert_to_eq(self, node):
+        raise NotImplementedError
+
+    def convert_to_neq(self, node):
+        raise NotImplementedError
+
+    def convert_to_not(self, node):
+        raise NotImplementedError
+
+    def convert_to_increment(self, node):
+        raise NotImplementedError
+
+    def convert_to_decrement(self, node):
+        raise NotImplementedError
+
+
+class EngineConfig:
+    def __init__(
+            self,
+            aor_op_rate=0.2,
+            lcr_op_rate=0.2,
+            ror_op_rate=0.2,
+            binop_expr_rate=0.1,
+            boolop_expr_rate=0.1,
+            num_lit_rate=0.1,
+            max_mutations=1,
+    ):
+        self.aor_op_rate = aor_op_rate
+        self.lcr_op_rate = lcr_op_rate
+        self.ror_op_rate = ror_op_rate
+        self.binop_expr_rate = binop_expr_rate
+        self.boolop_expr_rate = boolop_expr_rate
+        self.num_lit_rate = num_lit_rate
+        self.max_mutations = max_mutations
+
 
 class Engine:
-    def __init__(self, mutation_rate: float = 0.1, seed=1337):
-        self.mutation_rate = mutation_rate
+    def __init__(
+            self,
+            config: EngineConfig = EngineConfig(),
+            seed=1337
+    ):
+        self.config = config
         self.rng = random.default_rng(seed)
+        self.mutate_calls = 0
+        self.already_mutated = []
+        self.mutations = 0
+
+    def new(self):
+        engine = Engine(config=self.config, seed=self.rng.integers(0, 2 ** 32))
+        engine.already_mutated = self.already_mutated
+        return engine
 
     def pick(self, iterable):
         return self.rng.choice(iterable)
 
-    def mutate(self, node, conv_fn):
-        if self.rng.random() < self.mutation_rate:
+    def mutate_node(self, node, conv_fn, rate):
+        self.mutate_calls += 1
+        if self.mutations < self.config.max_mutations \
+                and self.mutate_calls not in self.already_mutated \
+                and self.rng.random() < rate:
+            self.mutations += 1
+            self.already_mutated.append(self.mutate_calls)
             return conv_fn(node)
         else:
             return node
 
 
 class Mutator(Converter):
     AOR_OPS = ["+", "-", "*", "/"]
+    BIN_OPS = ["a", "b"]
+    BOOL_OPS = ["a", "b", "true", "false", "not"]
+    LCR_OPS = ["and", "or"]
+    ROR_OPS = [">", "<", ">=", "<=", "==", "!="]
+    NUM_LIT_OP = ["++", "--"]
 
     def __init__(self, engine: Engine):
         self.engine = engine
 
-    def mutate_aor(self, node, current: Literal["+", "-", "*", "/"]):
+    def mutate_aor_op(self, node, current: Literal["+", "-", "*", "/"]):
         possible = [op for op in self.AOR_OPS if op != current]
         picked = self.engine.pick(possible)
 
@@ -65,4 +159,83 @@ def mutate_aor(self, node, current: Literal["+", "-", "*", "/"]):
         else:
             raise Exception("Unknown operator")
 
-        return self.engine.mutate(node, conv_fn)
+        return self.engine.mutate_node(node, conv_fn, self.engine.config.aor_op_rate)
+
+    def mutate_binop_expr(self, node):
+        picked = self.engine.pick(self.BIN_OPS)
+
+        conv_fn = None
+        if picked == "a":
+            conv_fn = self.convert_to_binop_a
+        elif picked == "b":
+            conv_fn = self.convert_to_binop_b
+        else:
+            raise Exception("Unknown operator")
+
+        return self.engine.mutate_node(node, conv_fn, self.engine.config.binop_expr_rate)
+
+    def mutate_lcr(self, node, current: Literal["and", "or"]):
+        possible = [op for op in self.LCR_OPS if op != current]
+        picked = self.engine.pick(possible)
+
+        conv_fn = None
+        if picked == "and":
+            conv_fn = self.convert_to_and
+        elif picked == "or":
+            conv_fn = self.convert_to_or
+        else:
+            raise Exception("Unknown operator")
+
+        return self.engine.mutate_node(node, conv_fn, self.engine.config.lcr_op_rate)
+
+    def mutate_boolop_expr(self, node):
+        picked = self.engine.pick(self.BOOL_OPS)
+
+        conv_fn = None
+        if picked == "a":
+            conv_fn = self.convert_to_boolop_a
+        elif picked == "b":
+            conv_fn = self.convert_to_boolop_b
+        elif picked == "true":
+            conv_fn = self.convert_to_true
+        elif picked == "false":
+            conv_fn = self.convert_to_false
+        elif picked == "not":
+            conv_fn = self.convert_to_not
+        else:
+            raise Exception("Unknown operator")
+
+        return self.engine.mutate_node(node, conv_fn, self.engine.config.boolop_expr_rate)
+
+    def mutate_ror(self, node, current: Literal[">", "<", ">=", "<=", "==", "!="]):
+        possible = [op for op in self.ROR_OPS if op != current]
+        picked = self.engine.pick(possible)
+
+        conv_fn = None
+        if picked == ">":
+            conv_fn = self.convert_to_gt
+        elif picked == "<":
+            conv_fn = self.convert_to_lt
+        elif picked == ">=":
+            conv_fn = self.convert_to_gte
+        elif picked == "<=":
+            conv_fn = self.convert_to_lte
+        elif picked == "==":
+            conv_fn = self.convert_to_eq
+        elif picked == "!=":
+            conv_fn = self.convert_to_neq
+        else:
+            raise Exception("Unknown operator")
+
+        return self.engine.mutate_node(node, conv_fn, self.engine.config.ror_op_rate)
+
+    def mutate_number_literal(self, node):
+        picked = self.engine.pick(self.NUM_LIT_OP)
+
+        conv_fn = None
+        if picked == "++":
+            conv_fn = self.convert_to_increment
+        elif picked == "--":
+            conv_fn = self.convert_to_decrement
+
+        return self.engine.mutate_node(node, conv_fn, self.engine.config.num_lit_rate)

python.py

@@ -19,25 +19,121 @@ def convert_to_add(self, node):
     def convert_to_sub(self, node):
         return ast.Sub()
 
+    def convert_to_and(self, node):
+        return ast.And()
+
+    def convert_to_or(self, node):
+        return ast.Or()
+
+    def convert_to_binop_a(self, node: ast.BinOp):
+        return node.left
+
+    def convert_to_binop_b(self, node: ast.BinOp):
+        return node.right
+
+    def convert_to_boolop_a(self, node: ast.BoolOp):
+        return node.values[0]
+
+    def convert_to_boolop_b(self, node: ast.BoolOp):
+        return node.values[1]
+
+    def convert_to_true(self, node):
+        return ast.NameConstant(value=True)
+
+    def convert_to_false(self, node):
+        return ast.NameConstant(value=False)
+
+    def convert_to_not(self, node):
+        return ast.UnaryOp(op=ast.Not(), operand=node)
+
+    def convert_to_gt(self, node):
+        return ast.Gt()
+
+    def convert_to_lt(self, node):
+        return ast.Lt()
+
+    def convert_to_gte(self, node):
+        return ast.GtE()
+
+    def convert_to_lte(self, node):
+        return ast.LtE()
+
+    def convert_to_eq(self, node):
+        return ast.Eq()
+
+    def convert_to_neq(self, node):
+        return ast.NotEq()
+
+
+    def convert_to_increment(self, node: ast.Constant):
+        return ast.Constant(value=node.value + 1)
+
+    def convert_to_decrement(self, node: ast.Constant):
+        return ast.Constant(value=node.value - 1)
+
+    def visit_BinOp(self, node: ast.BinOp):
+        mutated = self.mutate_binop_expr(node)
+        if mutated == node:
+            return self.generic_visit(node)
+        else:
+            return mutated
+
+    def visit_BoolOp(self, node: ast.BoolOp):
+        mutated = self.mutate_boolop_expr(node)
+        if mutated == node:
+            return self.generic_visit(node)
+        else:
+            return mutated
+
+    def visit_Constant(self, node: ast.Constant):
+        if type(node.value) == int:
+            return self.mutate_number_literal(node)
+        else:  # TODO: mutate bool? i think we shouldn't
+            return self.generic_visit(node)
+
     def visit_Sub(self, node):
-        return self.mutate_aor(node, "-")
+        return self.mutate_aor_op(node, "-")
 
     def visit_Add(self, node):
-        return self.mutate_aor(node, "+")
+        return self.mutate_aor_op(node, "+")
 
     def visit_Mult(self, node):
-        return self.mutate_aor(node, "*")
+        return self.mutate_aor_op(node, "*")
 
     def visit_Div(self, node):
-        return self.mutate_aor(node, "/")
+        return self.mutate_aor_op(node, "/")
+
+    def visit_And(self, node):
+        return self.mutate_lcr(node, "and")
+
+    def visit_Or(self, node):
+        return self.mutate_lcr(node, "or")
+
+    def visit_Gt(self, node):
+        return self.mutate_ror(node, ">")
+
+    def visit_Lt(self, node):
+        return self.mutate_ror(node, "<")
+
+    def visit_GtE(self, node):
+        return self.mutate_ror(node, ">=")
+
+    def visit_LtE(self, node):
+        return self.mutate_ror(node, "<=")
+
+    def visit_Eq(self, node):
+        return self.mutate_ror(node, "==")
+
+    def visit_NotEq(self, node):
+        return self.mutate_ror(node, "!=")
 
 
 if __name__ == "__main__":
     import os
     CODE = """
 def func(a, b):
     bleh = 1337
-    if a > b:
+    if a > b > b and True and True or False:
         return a - b
     elif a < b:
         return b - a
@@ -46,7 +142,19 @@ def func(a, b):
 """
 
     tree = ast.parse(CODE)
-    engine = Engine(0.9, int(os.urandom(4).hex(), 16))
-    mutator = PythonMutator(engine)
-    tree = mutator.visit(tree)
-    print(astunparse.unparse(tree))
+    print(ast.dump(tree))
+    engine = Engine(
+        seed=int(os.urandom(4).hex(), 16)
+    )
+    mutated_set = set()
+    for i in range(100):
+        mutator = PythonMutator(engine)
+        tree = ast.parse(CODE)
+        mutated = mutator.visit(tree)
+        if engine.mutations == 0:
+            continue
+        mutated_set.add(astunparse.unparse(mutated))
+        engine = engine.new()
+
+    for m in mutated_set:
+        print(m)