mv to fail

make_variations_basic/main.py

@@ -1,212 +0,0 @@
-# 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

@@ -1,26 +0,0 @@
-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

visualise/flatten.py

@@ -1,37 +0,0 @@
-'''
-- parse the AST for every line of code
-- add this to a graph of all possibly trees with frequency counts
-- plot this tree
-'''
-import json
-
-
-with open('visualise/trie.json', 'r') as f:
-    trie = json.load(f)
-
-
-def flatten_children(root):
-    children = []
-    for name, vals in root.items():
-        if name[0] == ' ':
-            continue
-        rr = {'name': name, 'value': vals[' count']}
-        rr['children'] = flatten_children(vals)
-        if not rr['children']:
-            del rr['children']
-        children.append(rr)
-
-    tot = sum(child['value'] for child in children)
-    for child in children:
-        child['value'] = child['value'] / tot
-
-    return children
-
-
-trie = {
-    "name": "Module",
-    "children": flatten_children(trie)
-}
-
-with open('visualise/trie.flat.json', 'w') as f:
-    f.write(json.dumps(trie))

visualise/main.py

@@ -1,37 +0,0 @@
-'''
-- parse the AST for every line of code
-- add this to a graph of all possibly trees with frequency counts
-- plot this tree
-'''
-import ast
-import json
-from tqdm import tqdm
-
-
-trie = {}
-
-
-class Reader:
-    def __init__(self, trie, code):
-        self.trie = trie
-        self.root = ast.parse(code)
-
-    def run(self):
-        return self.add_code(self.trie, self.root)
-
-    def add_code(self, cursor, node):
-        for child in ast.iter_child_nodes(node):
-            name = type(child).__name__
-            cursor[name] = cursor.get(name, {' count': 0})
-            cursor[name][' count'] += 1            
-            cursor[name] = self.add_code(cursor[name], child)
-        return cursor
-
-
-with open('data.jsonl', 'r', encoding="utf-8") as f:
-    for id_, line in tqdm(enumerate(f), total=8968897):
-        trie = Reader(trie, json.loads(line)['code']).run()
-
-
-with open('visualise/trie.json', 'w') as f:
-    f.write(json.dumps(trie))