{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{user.username}\n"
     ]
    }
   ],
   "source": [
    "from transformers import AutoTokenizer, AutoModelForSeq2SeqLM\n",
    "\n",
    "tokenizer = AutoTokenizer.from_pretrained(\"Salesforce/codet5-base\")\n",
    "model = AutoModelForSeq2SeqLM.from_pretrained(\"Salesforce/codet5-base\")\n",
    "\n",
    "text = \"def greet(user): print(f'hello <extra_id_0>!')\"\n",
    "input_ids = tokenizer(text, return_tensors=\"pt\").input_ids\n",
    "\n",
    "# simply generate a single sequence\n",
    "generated_ids = model.generate(input_ids, max_length=8)\n",
    "print(tokenizer.decode(generated_ids[0], skip_special_tokens=True))\n",
    "# this prints \"{user.username}\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "import ast\n",
    "\n",
    "def filter_codes(codes):\n",
    "    codes = list(set(codes))\n",
    "    new_codes = []\n",
    "    for code in codes:\n",
    "        if ';' in code:\n",
    "            code = code[code.index(';'):]\n",
    "        try:\n",
    "            ast.parse(code)\n",
    "        except Exception:\n",
    "            continue\n",
    "        new_codes.append(code)\n",
    "    return new_codes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def temp_value(value):\n",
    "    if value[0] == '[' and value[-1] == ']':\n",
    "        return '[<extra_id_0>]'\n",
    "    if value[0] == '\"' and value[-1] == '\"':\n",
    "        return '\"<extra_id_0>\"'\n",
    "    if value[0] == \"'\" and value[-1] == \"'\":\n",
    "        return \"'<extra_id_0>'\"\n",
    "    if value[0] == '{' and value[-1] == '}':\n",
    "        return '{<extra_id_0>}'\n",
    "    return '<extra_id_0>'\n",
    "\n",
    "def temp_var(var):\n",
    "    value = var[4:]\n",
    "    return var[:4] + temp_value(value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_code(start, code):\n",
    "    return f'def main(): {\"; \".join(start)}; {code}; return {\", \".join([v.split()[0] for v in start])}'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "import ast\n",
    "\n",
    "def filter_codes(codes):\n",
    "    codes = list(set(codes))\n",
    "    new_codes = []\n",
    "    for code in codes:\n",
    "        if ';' in code:\n",
    "            code = code[code.index(';'):]\n",
    "        try:\n",
    "            ast.parse(code)\n",
    "        except Exception:\n",
    "            continue\n",
    "        new_codes.append(code)\n",
    "    return new_codes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "def alt_from_code(code):\n",
    "    input_ids = tokenizer(code, return_tensors=\"pt\").input_ids\n",
    "    generated_ids = model.generate(input_ids, num_return_sequences=100, max_length=20, do_sample=True, temperature=1.0)\n",
    "    return filter_codes(tokenizer.batch_decode(generated_ids, skip_special_tokens=True))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "import errno\n",
    "import os\n",
    "import signal\n",
    "import functools\n",
    "\n",
    "class TimeoutError(Exception):\n",
    "    pass\n",
    "\n",
    "def timeout(seconds=10, error_message=os.strerror(errno.ETIME)):\n",
    "    def decorator(func):\n",
    "        def _handle_timeout(signum, frame):\n",
    "            raise TimeoutError(error_message)\n",
    "\n",
    "        @functools.wraps(func)\n",
    "        def wrapper(*args, **kwargs):\n",
    "            signal.signal(signal.SIGALRM, _handle_timeout)\n",
    "            signal.alarm(seconds)\n",
    "            try:\n",
    "                result = func(*args, **kwargs)\n",
    "            finally:\n",
    "                signal.alarm(0)\n",
    "            return result\n",
    "\n",
    "        return wrapper\n",
    "\n",
    "    return decorator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "def state_dict_to_str(state):\n",
    "    vals = []\n",
    "    for k, v in state.items():\n",
    "        vals.append(\n",
    "            f'{k} = {v}'\n",
    "        )\n",
    "    vals = sorted(vals)\n",
    "    return '; '.join(vals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "def trace_code(start_state: str, code: str):\n",
    "    state = {}\n",
    "    try:\n",
    "        exec(start_state, {}, state)\n",
    "    except Exception:\n",
    "        return\n",
    "    start_state = dict(state)\n",
    "    try:\n",
    "        exec(code, {}, state)\n",
    "    except Exception:\n",
    "        return\n",
    "    return state_dict_to_str(start_state), code, state_dict_to_str(state)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'start': 'g = 100; i = 1; l = [1, 100, 1]',\n",
       "  'code': 'g += l[i]',\n",
       "  'end': 'g = 200; i = 1; l = [1, 100, 1]'},\n",
       " {'start': 'g = 100; i = 1; l = [1, 1]',\n",
       "  'code': 'g += l[i]',\n",
       "  'end': 'g = 101; i = 1; l = [1, 1]'},\n",
       " {'start': 'g = 100; i = 1; l = [1, 1, 1]',\n",
       "  'code': 'g += l[i]',\n",
       "  'end': 'g = 101; i = 1; l = [1, 1, 1]'},\n",
       " {'start': 'g = 100; i = 1; l = [100, 100]',\n",
       "  'code': 'g += l[i]',\n",
       "  'end': 'g = 200; i = 1; l = [100, 100]'},\n",
       " {'start': 'g = 100; i = 1; l = [50, 50, 50, 40]',\n",
       "  'code': 'g += l[i]',\n",
       "  'end': 'g = 150; i = 1; l = [50, 50, 50, 40]'},\n",
       " {'start': 'g = 100; i = 1; l = [0, 10]',\n",
       "  'code': 'g += l[i]',\n",
       "  'end': 'g = 110; i = 1; l = [0, 10]'},\n",
       " {'start': 'g = 100; i = 1; l = [100, 900, 10, 10]',\n",
       "  'code': 'g += l[i]',\n",
       "  'end': 'g = 1000; i = 1; l = [100, 900, 10, 10]'},\n",
       " {'start': 'g = 100; i = 1; l = [1, 1, 2]',\n",
       "  'code': 'g += l[i]',\n",
       "  'end': 'g = 101; i = 1; l = [1, 1, 2]'},\n",
       " {'start': 'g = 100; i = 1; l = [100, 100, 100, 0, 0]',\n",
       "  'code': 'g += l[i]',\n",
       "  'end': 'g = 200; i = 1; l = [100, 100, 100, 0, 0]'}]"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def get_working_alts(other_vars, var_alts, code):\n",
    "    rows = []\n",
    "    for alt in var_alts:\n",
    "        start = other_vars + [alt]\n",
    "        result = trace_code('; '.join(start), code)\n",
    "        if result:\n",
    "            rows.append({'start': result[0], 'code': result[1], 'end': result[2]})\n",
    "    return rows\n",
    "\n",
    "test_alt_vars = [\n",
    "    'l = [1, 100, 1]',\n",
    "    'l = [1, 1]',\n",
    "    'l = [f]',\n",
    "    'l = [1, 1, 1,]',\n",
    "    'l = [i = 10]',\n",
    "    'l = [100, 100]',\n",
    "    'l = [l[i].max(), l[i].min()]',\n",
    "    'l = [1]',\n",
    "    'l = [50, 50, 50, 40]',\n",
    "    'l = [0, 10]',\n",
    "    'l = [100, 900, 10, 10]',\n",
    "    'l = [i, 1, 2]',\n",
    "    'l = [100, 100, 100, 0, 0]'\n",
    "]\n",
    "get_working_alts(['g = 100', 'i = 1'], test_alt_vars, 'g += l[i]')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(['g = 100', 'i = 1'],\n",
       " ['l = [1, 2]',\n",
       "  'l = [0,1,2,3,3,4,5,6,9]',\n",
       "  'l = [0.01]',\n",
       "  'l = [5, 6, 8, 12,]',\n",
       "  'l = [g * 2, 1]',\n",
       "  'l = [g / 100.0 + i]',\n",
       "  'l = [100, 100,]',\n",
       "  'l = [0, 1]',\n",
       "  'l = [1]',\n",
       "  'l = [15, 100, 1000100, i,]',\n",
       "  'l = [100, 1, 0]',\n",
       "  'l = [i, m]',\n",
       "  'l = [.1,.2]',\n",
       "  'l = [100100]',\n",
       "  'l = [100, 100,100]',\n",
       "  'l = [1, 2, 3, 4]',\n",
       "  'l = [0.001, 0.001, 0.001, 1.001]',\n",
       "  'l = [100, 100, 100]',\n",
       "  'l = [0.9]',\n",
       "  'l = [1, 2, 3]',\n",
       "  'l = [g / i]',\n",
       "  'l = [g]',\n",
       "  'l = [i - 1]',\n",
       "  'l = [1, 1, 1]',\n",
       "  'l = [10, 20]',\n",
       "  'l = [0, 2, 3]',\n",
       "  'l = [100]',\n",
       "  'l = [1, 1, 2]',\n",
       "  'l = [10109090909090909090909090909090909]',\n",
       "  'l = [g, i]',\n",
       "  'l = [1, 2,2]',\n",
       "  'l = [0, 0]',\n",
       "  'l = [10, 20, 20]',\n",
       "  'l = [i]',\n",
       "  'l = [g, 1]',\n",
       "  'l = [0, 1, 0]',\n",
       "  'l = [100, 90]',\n",
       "  'l = [10, 5, 6]',\n",
       "  'l = [g, g-i, l]',\n",
       "  'l = [0]',\n",
       "  'l = [1,2,3,2,7,5,6,8,9]',\n",
       "  'l = [floa_e_b, floa_e_c, f]',\n",
       "  'l = [100, 100, 1]',\n",
       "  'l = [0.5, 1.5]',\n",
       "  'l = [100, 1001, 1001, 1012, 1015]'])"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def get_alts_for_var(start_vars, alt_i, code):\n",
    "    start_vars[alt_i] = temp_var(start_vars[alt_i])\n",
    "    code = make_code(start_vars, row['code'])\n",
    "    var_alts = alt_from_code(code)\n",
    "    alt_var_temp = start_vars[alt_i]\n",
    "    del start_vars[alt_i]\n",
    "    return start_vars, [alt_var_temp.replace('<extra_id_0>', alt) for alt in var_alts]\n",
    "\n",
    "alt_start_vars, var_alts = get_alts_for_var(\n",
    "    ['g = 100', 'i = 1', 'l = [100, 100, 0, 0, -100, -100]'], 2, 'g += l[i]'\n",
    ")\n",
    "alt_start_vars, var_alts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(53,\n",
       " [{'start': 'g = 1; i = 1; l = [100, 100, 0, 0, -100, -100]',\n",
       "   'code': 'g += l[i]',\n",
       "   'end': 'g = 101; i = 1; l = [100, 100, 0, 0, -100, -100]'},\n",
       "  {'start': 'g = 2; i = 1; l = [100, 100, 0, 0, -100, -100]',\n",
       "   'code': 'g += l[i]',\n",
       "   'end': 'g = 102; i = 1; l = [100, 100, 0, 0, -100, -100]'},\n",
       "  {'start': 'g = 3; i = 1; l = [100, 100, 0, 0, -100, -100]',\n",
       "   'code': 'g += l[i]',\n",
       "   'end': 'g = 103; i = 1; l = [100, 100, 0, 0, -100, -100]'}])"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def make_alternatives(row):\n",
    "    start_vars = row['start'].split('; ')\n",
    "\n",
    "    alts = []\n",
    "    for i in range(len(start_vars)):\n",
    "        alt_start_vars, var_alts = get_alts_for_var(list(start_vars), i, row['code'])\n",
    "        alts += get_working_alts(alt_start_vars, var_alts, row['code'])\n",
    "\n",
    "    return alts\n",
    "\n",
    "alts = make_alternatives(\n",
    "    {'start': 'g = 100; i = 1; l = [100, 100, 0, 0, -100, -100]',\n",
    "    'code': 'g += l[i]',\n",
    "    'end': 'g = 200; i = 1; l = [100, 100, 0, 0, -100, -100]'}\n",
    ")\n",
    "len(alts), alts[:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "\n",
    "with open('../data.jsonl', 'r', encoding=\"utf-8\") as f:\n",
    "    for id_, line in enumerate(f):\n",
    "        row = json.loads(line)\n",
    "        alts = make_alternatives(row)\n",
    "        # TODO: save alts\n",
    "        break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['1, 2',\n",
       " '1, 0',\n",
       " '1, 1, 1, 1',\n",
       " '1, 1',\n",
       " '\"ab\",i,2',\n",
       " '0, 1',\n",
       " '8',\n",
       " '\"s\", \"m\", \"v\", \"r \"',\n",
       " 'g, - p',\n",
       " '1, 1, 1,',\n",
       " '7, 5, 6',\n",
       " 'g, i, l',\n",
       " '1',\n",
       " '1,1,2,3',\n",
       " '1, 2, 2',\n",
       " '\"ab\", \"aa\", \"ab\", \"aa\"',\n",
       " '1, 2, 3, 4',\n",
       " '\"ab\",\"ace\",\"ae\",\"ad\"',\n",
       " 'i, i',\n",
       " '\"ab\", \"a\", \"e\"',\n",
       " '100, 100, 100',\n",
       " '1,3,3,4,5,6,7,9,0',\n",
       " '\" a\"',\n",
       " '0, 1, 2',\n",
       " '0, 1, 1, 1, 0',\n",
       " '\"ab\", \"bal,ca\"',\n",
       " 'g,i, l [ i ]',\n",
       " '1, 3,4, 6',\n",
       " 'a',\n",
       " '1, 2, 3',\n",
       " '9, 9',\n",
       " '( 1)',\n",
       " '2, - 1, - 1',\n",
       " '0 | 1 | 0|0',\n",
       " '{ 1 }',\n",
       " 'i - 1',\n",
       " 'o, l1, o2, l',\n",
       " '\"ab\"',\n",
       " '1, 1, 2',\n",
       " 'g, i',\n",
       " '0, 0',\n",
       " '\"a\"',\n",
       " 'i, l',\n",
       " 'i',\n",
       " '0,0',\n",
       " '- l [ i ]',\n",
       " '1, 2, 3, 1',\n",
       " 'l[ i - 1 ]',\n",
       " '\"1\",\"2\", \"3\",\"4\", \"5\"',\n",
       " 'g, g, i']"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "code ='def main(): g = \"ab\"; i = 1; l = [<extra_id_0>]; g += l[i]; return g, i, l'\n",
    "\n",
    "input_ids = tokenizer(code, return_tensors=\"pt\").input_ids\n",
    "generated_ids = model.generate(input_ids, num_return_sequences=100, max_length=20, do_sample=True, temperature=1.0)\n",
    "filter_codes(tokenizer.batch_decode(generated_ids, skip_special_tokens=True))\n",
    "\n",
    "# 100 samples -> ~8 valid alternatives, 3.1s on macos CPU"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['<pad><s><extra_id_0>5<extra_id_1>g i l [ 0</s><pad><pad>',\n",
       " '<pad><s><extra_id_0>0<extra_id_1>0, 0, 0</s><pad><pad>',\n",
       " '<pad><s><extra_id_0>0<extra_id_1>1 1 2, 1</s><pad><pad>',\n",
       " \"<pad><s><extra_id_0>'<extra_id_1>i</s><pad><pad><pad><pad><pad><pad>\",\n",
       " '<pad><s><extra_id_0>0<extra_id_1>a t</s><pad><pad><pad><pad><pad>',\n",
       " '<pad><s><extra_id_0>0.0<extra_id_1>e. f_i</s>',\n",
       " '<pad><s><extra_id_0>\" \"<extra_id_1>1</s><pad><pad><pad><pad><pad>',\n",
       " '<pad><s><extra_id_0>0<extra_id_1>n = 1 l =</s><pad><pad>',\n",
       " '<pad><s><extra_id_0>0, 0, 1<extra_id_1>1</s><pad><pad>',\n",
       " '<pad><s><extra_id_0>1<extra_id_1>k y y x z</s><pad><pad>']"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "code ='def main(): g = <extra_id_0>; i = 1; l = [<extra_id_1>]; g += l[i]; return g, i, l'\n",
    "\n",
    "input_ids = tokenizer(code, return_tensors=\"pt\").input_ids\n",
    "generated_ids = model.generate(input_ids, num_return_sequences=10, max_length=20, do_sample=True, temperature=1.0)\n",
    "tokenizer.batch_decode(generated_ids)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "ced6a873299cbeeefe969ab88294103b352f8c83b6537b9e08e8739795321d60"
  },
  "kernelspec": {
   "display_name": "Python 3.9.9 64-bit ('3.9.9': pyenv)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.9"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}