already working

Author: cassanof

__init__.py

@@ -0,0 +1,68 @@
+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
+
+from typing import Literal, Callable, Any
+
+Node = Any  # TODO: fix later
+
+
+class Converter:
+    def __init__(self):
+        pass
+
+    def convert_to_div(self, node):
+        raise NotImplementedError
+
+    def convert_to_mult(self, node):
+        raise NotImplementedError
+
+    def convert_to_add(self, node):
+        raise NotImplementedError
+
+    def convert_to_sub(self, node):
+        raise NotImplementedError
+
+
+class Engine:
+    def __init__(self, mutation_rate: float = 0.1, seed=1337):
+        self.mutation_rate = mutation_rate
+        self.rng = random.default_rng(seed)
+
+    def pick(self, iterable):
+        return self.rng.choice(iterable)
+
+    def mutate(self, node, conv_fn):
+        if self.rng.random() < self.mutation_rate:
+            return conv_fn(node)
+        else:
+            return node
+
+
+class Mutator(Converter):
+    AOR_OPS = ["+", "-", "*", "/"]
+
+    def __init__(self, engine: Engine):
+        self.engine = engine
+
+    def mutate_aor(self, node, current: Literal["+", "-", "*", "/"]):
+        possible = [op for op in self.AOR_OPS if op != current]
+        picked = self.engine.pick(possible)
+
+        conv_fn = None
+        if picked == "+":
+            conv_fn = self.convert_to_add
+        elif picked == "-":
+            conv_fn = self.convert_to_sub
+        elif picked == "*":
+            conv_fn = self.convert_to_mult
+        elif picked == "/":
+            conv_fn = self.convert_to_div
+        else:
+            raise Exception("Unknown operator")
+
+        return self.engine.mutate(node, conv_fn)

engine.py

@@ -0,0 +1,52 @@
+import ast
+from engine import Mutator, Engine
+import astunparse
+
+
+class PythonMutator(ast.NodeTransformer, Mutator):
+    def __init__(self, engine: Engine) -> None:
+        super().__init__(engine)
+
+    def convert_to_div(self, node):
+        return ast.Div()
+
+    def convert_to_mult(self, node):
+        return ast.Mult()
+
+    def convert_to_add(self, node):
+        return ast.Add()
+
+    def convert_to_sub(self, node):
+        return ast.Sub()
+
+    def visit_Sub(self, node):
+        return self.mutate_aor(node, "-")
+
+    def visit_Add(self, node):
+        return self.mutate_aor(node, "+")
+
+    def visit_Mult(self, node):
+        return self.mutate_aor(node, "*")
+
+    def visit_Div(self, node):
+        return self.mutate_aor(node, "/")
+
+
+if __name__ == "__main__":
+    import os
+    CODE = """
+def func(a, b):
+    bleh = 1337
+    if a > b:
+        return a - b
+    elif a < b:
+        return b - a
+    else: # a == b
+        return 0
+"""
+
+    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))