basic variations attempt

make_variations_basic/main.py

@@ -0,0 +1,212 @@
+# did 2563140/9000000
+import gzip
+import json
+from typing import List
+from tqdm import tqdm
+from random import randint, random, sample
+from astpretty import pprint
+from copy import deepcopy
+from string import ascii_letters
+import ast
+
+
+from utils import TimeoutError, timeout
+
+
+def write_rows(rows):
+    rows = [json.dumps(r) for r in rows]
+    with open('data.10_simple_variations.jsonl', 'a') as f:
+        f.writelines('\n'.join(rows) + '\n')
+
+
+def write_rows_compressed(rows):
+    rows = [json.dumps(r) for r in rows]
+    with gzip.open('data.10_simple_variations.jsonl.gz', 'wb') as f:
+        f.write('\n'.join(rows).encode() + b'\n')
+
+
+class AlternativeList(ast.NodeTransformer):
+    def __init__(self):
+        self.n_changes = 0
+        super().__init__()
+
+    def visit_List(self, node: List):
+        code = ast.unparse(node)
+        try:
+            list_val = eval(code)
+        except Exception:
+            return node
+
+        for _ in range(randint(0, 3)):
+            list_val.append(randint(-999, 999))
+
+        if not list_val:
+            list_val.append(randint(-999, 999))
+
+        list_val = sample(list_val, randint(1, len(list_val)))
+
+        self.n_changes += 1
+        return ast.parse(str(list_val)).body[0].value
+
+
+class AlternativeConstant(ast.NodeTransformer):
+    def __init__(self):
+        self.n_changes = 0
+        super().__init__()
+
+    def visit_Constant(self, node):
+        '''
+            Switch constant values to simple variations
+        '''
+        if type(node.value) is int:
+            if randint(0, 1) == 1:
+                node.value = randint(-9, 9)
+            else:
+                node.value = randint(-999, 999)
+        elif type(node.value) is str:
+            if randint(0, 1) == 1 and node.value:
+                if node.value:
+                    node.value = ''.join(sample(node.value, randint(1, len(node.value))))
+                else:
+                    self.n_changes -= 1
+            else:
+                node.value = ''.join(sample(ascii_letters, randint(1, 4)))
+        elif type(node.value) is float:
+            if randint(0, 1) == 1:
+                node.value = random()
+            else:
+                node.value = random() * randint(-999, 999)
+        elif type(node.value) is bool:
+            node.value = bool(randint(0, 1))
+        else:
+            self.n_changes -= 1
+        self.n_changes += 1
+        return super().visit_Constant(node)
+
+
+class AlternativeNames(ast.NodeTransformer):
+
+    def visit_Name(self, node):
+        return ast.copy_location(ast.Subscript(
+            value=ast.Name(id='data', ctx=ast.Load()),
+            slice=ast.Index(value=ast.Str(s=node.id)),
+            ctx=node.ctx
+        ), node)
+
+
+def state_dict_to_str(state):
+    vals = []
+    for k, v in state.items():
+        vals.append(
+            f'{k} = {v}'
+        )
+    vals = sorted(vals)
+    return ';'.join(vals)
+
+
+@timeout(seconds=3)
+def trace_code(start_state: str, code: str):
+    state = {}
+    try:
+        exec(start_state, {}, state)
+    except Exception:
+        return
+    start_state = dict(state)
+    try:
+        exec(code, {}, state)
+    except Exception:
+        return
+    return state_dict_to_str(start_state), code, state_dict_to_str(state)
+
+
+def make_alternative_rows(start, code):
+    variations = {}
+    n_tries = 0
+    state_root = ast.parse(start)
+
+    while len(variations) < 10 and n_tries < 20:
+
+        alt_state_root = None
+
+        node_transformer = AlternativeList()
+        try:
+            alt_state_root = node_transformer.visit(deepcopy(state_root))
+        except Exception:
+            pass
+
+        if node_transformer.n_changes < 1:
+            node_transformer = AlternativeConstant()
+            try:
+                alt_state_root = node_transformer.visit(deepcopy(alt_state_root))
+            except Exception:
+                pass
+            if node_transformer.n_changes < 1:
+                n_tries += 10
+
+        if alt_state_root:
+            alt_start = ast.unparse(alt_state_root)
+            try:
+                alt_start_code_end = trace_code(alt_start, code)
+                if alt_start_code_end:
+                    variations[alt_start] = alt_start_code_end
+            except TimeoutError:
+                pass
+
+        n_tries += 1
+
+    # TODO change the names (keep alphabetical order)
+    '''
+    get number of vals in start states (N)
+    get N random lowercase letters in alphabetical order
+    parse start state and shuffle the expr.body
+    make name map old->new using new characters
+    use visitor with name map to swap variable names using map
+        do this for start, code, end seperately
+    '''
+    return [
+        {'start': st, 'code': cd, 'end': en} for st, cd, en in variations.values()
+    ]
+
+
+STATS = {
+    'alt_count': 0,
+    'num_rows': 0
+}
+
+
+with open('new_all_states.txt', 'r') as f:
+    rows = []
+    prev_lines = []
+    for i, line in tqdm(enumerate(f), total=9_000_000):
+        line = line.strip()
+
+        if line[-1] != ';':
+            prev_lines.append(line)
+            continue
+        elif prev_lines:
+            line = '\n'.join(prev_lines) + '\n' + line
+            prev_lines = []
+
+        start, code_end = line.split('; code: ')
+        start = start.removeprefix('state: ')
+        code, end = code_end.split('; output: ')
+        end = end.removesuffix(';')
+
+        rows.append({
+            'start': start, 'code': code, 'end': end
+        })
+        alt_rows = make_alternative_rows(start, code)
+        rows += alt_rows
+
+        STATS['alt_count'] += len(alt_rows)
+        STATS['num_rows'] += 1
+
+        if len(rows) > 1_000:
+            write_rows_compressed(rows)
+            rows = []
+
+write_rows_compressed(rows)
+
+
+print(STATS)
+print(STATS['alt_count'] / STATS['num_rows'])

make_variations_basic/utils.py

@@ -0,0 +1,26 @@
+import errno
+import os
+import signal
+import functools
+
+class TimeoutError(Exception):
+    pass
+
+def timeout(seconds=10, error_message=os.strerror(errno.ETIME)):
+    def decorator(func):
+        def _handle_timeout(signum, frame):
+            raise TimeoutError(error_message)
+
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            signal.signal(signal.SIGALRM, _handle_timeout)
+            signal.alarm(seconds)
+            try:
+                result = func(*args, **kwargs)
+            finally:
+                signal.alarm(0)
+            return result
+
+        return wrapper
+
+    return decorator