notebooks/openbugger.ipynb

{
  "cells": [
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "# OpenBugger\n",
        "This notebook is a self-contained demo of the OpenBugger package that automatically bugs python code using LibCST"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "This plan for the notebook is to develop all the components necessary to construct a pipeline that\n",
        "starting from a python script, it extracts its Concrete Syntax Tree and use it to apply a sequence of revertable syntactical code-mutation to automatically generate training data for debugging language models.\n",
        "\n",
        "1. Tools to ensure that the sequence of modification is consistent and does not overwrite previously introduced mutations.\n",
        "2. Bugger class to store the local context of multiple bugs that can be applied in a chain.\n",
        "3. InverseTransformer class that is able to reverse the transformation of any other transformer sharing the same bugger context.\n",
        "4. 5/12 example LibCST transformers that can each implement a different logical bug.  \n",
        "5. Use the InverseTransformer to generate accurate debugging instructions to be used as training data for Large Language Models."
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## LibCST"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {},
      "outputs": [],
      "source": [
        "from libcst.codemod import CodemodContext, Codemod\n",
        "from libcst.metadata import MetadataWrapper\n",
        "from libcst import Equal, GreaterThanEqual, GreaterThan, CSTNode, Module\n",
        "from typing import List\n",
        "from copy import deepcopy\n",
        "import libcst as cst\n",
        "from libcst.codemod import CodemodContext, ContextAwareTransformer, ContextAwareVisitor\n",
        "from libcst.metadata import BatchableMetadataProvider, PositionProvider, CodePosition, CodeRange\n",
        "import libcst.matchers as m\n",
        "import uuid\n",
        "from openbugger.bugger import deep_equals_with_print"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Value mismatch in field 'value': y != z\n",
            "Value mismatch in field 'value': Name(\n",
            "    value='y',\n",
            "    lpar=[],\n",
            "    rpar=[],\n",
            ") != Name(\n",
            "    value='z',\n",
            "    lpar=[],\n",
            "    rpar=[],\n",
            ")\n",
            "Value mismatch in field 'right': Subscript(\n",
            "    value=Name(\n",
            "        value='y',\n",
            "        lpar=[],\n",
            "        rpar=[],\n",
            "    ),\n",
            "    slice=[\n",
            "        SubscriptElement(\n",
            "            slice=Slice(\n",
            "                lower=Integer(\n",
            "                    value='2',\n",
            "                    lpar=[],\n",
            "                    rpar=[],\n",
            "                ),\n",
            "                upper=Integer(\n",
            "                    value='10',\n",
            "                    lpar=[],\n",
            "                    rpar=[],\n",
            "                ),\n",
            "                step=None,\n",
            "                first_colon=Colon(\n",
            "                    whitespace_before=SimpleWhitespace(\n",
            "                        value='',\n",
            "                    ),\n",
            "                    whitespace_after=SimpleWhitespace(\n",
            "                        value='',\n",
            "                    ),\n",
            "                ),\n",
            "                second_colon=MaybeSentinel.DEFAULT,\n",
            "            ),\n",
            "            comma=MaybeSentinel.DEFAULT,\n",
            "        ),\n",
            "    ],\n",
            "    lbracket=LeftSquareBracket(\n",
            "        whitespace_after=SimpleWhitespace(\n",
            "            value='',\n",
            "        ),\n",
            "    ),\n",
            "    rbracket=RightSquareBracket(\n",
            "        whitespace_before=SimpleWhitespace(\n",
            "            value='',\n",
            "        ),\n",
            "    ),\n",
            "    lpar=[],\n",
            "    rpar=[],\n",
            "    whitespace_after_value=SimpleWhitespace(\n",
            "        value='',\n",
            "    ),\n",
            ") != Subscript(\n",
            "    value=Name(\n",
            "        value='z',\n",
            "        lpar=[],\n",
            "        rpar=[],\n",
            "    ),\n",
            "    slice=[\n",
            "        SubscriptElement(\n",
            "            slice=Slice(\n",
            "                lower=Integer(\n",
            "                    value='2',\n",
            "                    lpar=[],\n",
            "                    rpar=[],\n",
            "                ),\n",
            "                upper=Integer(\n",
            "                    value='10',\n",
            "                    lpar=[],\n",
            "                    rpar=[],\n",
            "                ),\n",
            "                step=None,\n",
            "                first_colon=Colon(\n",
            "                    whitespace_before=SimpleWhitespace(\n",
            "                        value='',\n",
            "                    ),\n",
            "                    whitespace_after=SimpleWhitespace(\n",
            "                        value='',\n",
            "                    ),\n",
            "                ),\n",
            "                second_colon=MaybeSentinel.DEFAULT,\n",
            "            ),\n",
            "            comma=MaybeSentinel.DEFAULT,\n",
            "        ),\n",
            "    ],\n",
            "    lbracket=LeftSquareBracket(\n",
            "        whitespace_after=SimpleWhitespace(\n",
            "            value='',\n",
            "        ),\n",
            "    ),\n",
            "    rbracket=RightSquareBracket(\n",
            "        whitespace_before=SimpleWhitespace(\n",
            "            value='',\n",
            "        ),\n",
            "    ),\n",
            "    lpar=[],\n",
            "    rpar=[],\n",
            "    whitespace_after_value=SimpleWhitespace(\n",
            "        value='',\n",
            "    ),\n",
            ")\n",
            "Value mismatch in field 'value': BinaryOperation(\n",
            "    left=BinaryOperation(\n",
            "        left=Subscript(\n",
            "            value=Name(\n",
            "                value='x',\n",
            "                lpar=[],\n",
            "                rpar=[],\n",
            "            ),\n",
            "            slice=[\n",
            "                SubscriptElement(\n",
            "                    slice=Index(\n",
            "                        value=Integer(\n",
            "                            value='2',\n",
            "                            lpar=[],\n",
            "                            rpar=[],\n",
            "                        ),\n",
            "                        star=None,\n",
            "                        whitespace_after_star=None,\n",
            "                    ),\n",
            "                    comma=MaybeSentinel.DEFAULT,\n",
            "                ),\n",
            "            ],\n",
            "            lbracket=LeftSquareBracket(\n",
            "                whitespace_after=SimpleWhitespace(\n",
            "                    value='',\n",
            "                ),\n",
            "            ),\n",
            "            rbracket=RightSquareBracket(\n",
            "                whitespace_before=SimpleWhitespace(\n",
            "                    value='',\n",
            "                ),\n",
            "            ),\n",
            "            lpar=[],\n",
            "            rpar=[],\n",
            "            whitespace_after_value=SimpleWhitespace(\n",
            "                value='',\n",
            "            ),\n",
            "        ),\n",
            "        operator=Add(\n",
            "            whitespace_before=SimpleWhitespace(\n",
            "                value=' ',\n",
            "            ),\n",
            "            whitespace_after=SimpleWhitespace(\n",
            "                value=' ',\n",
            "            ),\n",
            "        ),\n",
            "        right=Integer(\n",
            "            value='1',\n",
            "            lpar=[],\n",
            "            rpar=[],\n",
            "        ),\n",
            "        lpar=[],\n",
            "        rpar=[],\n",
            "    ),\n",
            "    operator=Add(\n",
            "        whitespace_before=SimpleWhitespace(\n",
            "            value='',\n",
            "        ),\n",
            "        whitespace_after=SimpleWhitespace(\n",
            "            value='',\n",
            "        ),\n",
            "    ),\n",
            "    right=Subscript(\n",
            "        value=Name(\n",
            "            value='y',\n",
            "            lpar=[],\n",
            "            rpar=[],\n",
            "        ),\n",
            "        slice=[\n",
            "            SubscriptElement(\n",
            "                slice=Slice(\n",
            "                    lower=Integer(\n",
            "                        value='2',\n",
            "                        lpar=[],\n",
            "                        rpar=[],\n",
            "                    ),\n",
            "                    upper=Integer(\n",
            "                        value='10',\n",
            "                        lpar=[],\n",
            "                        rpar=[],\n",
            "                    ),\n",
            "                    step=None,\n",
            "                    first_colon=Colon(\n",
            "                        whitespace_before=SimpleWhitespace(\n",
            "                            value='',\n",
            "                        ),\n",
            "                        whitespace_after=SimpleWhitespace(\n",
            "                            value='',\n",
            "                        ),\n",
            "                    ),\n",
            "                    second_colon=MaybeSentinel.DEFAULT,\n",
            "                ),\n",
            "                comma=MaybeSentinel.DEFAULT,\n",
            "            ),\n",
            "        ],\n",
            "        lbracket=LeftSquareBracket(\n",
            "            whitespace_after=SimpleWhitespace(\n",
            "                value='',\n",
            "            ),\n",
            "        ),\n",
            "        rbracket=RightSquareBracket(\n",
            "            whitespace_before=SimpleWhitespace(\n",
            "                value='',\n",
            "            ),\n",
            "        ),\n",
            "        lpar=[],\n",
            "        rpar=[],\n",
            "        whitespace_after_value=SimpleWhitespace(\n",
            "            value='',\n",
            "        ),\n",
            "    ),\n",
            "    lpar=[],\n",
            "    rpar=[],\n",
            ") != BinaryOperation(\n",
            "    left=BinaryOperation(\n",
            "        left=Subscript(\n",
            "            value=Name(\n",
            "                value='x',\n",
            "                lpar=[],\n",
            "                rpar=[],\n",
            "            ),\n",
            "            slice=[\n",
            "                SubscriptElement(\n",
            "                    slice=Index(\n",
            "                        value=Integer(\n",
            "                            value='2',\n",
            "                            lpar=[],\n",
            "                            rpar=[],\n",
            "                        ),\n",
            "                        star=None,\n",
            "                        whitespace_after_star=None,\n",
            "                    ),\n",
            "                    comma=MaybeSentinel.DEFAULT,\n",
            "                ),\n",
            "            ],\n",
            "            lbracket=LeftSquareBracket(\n",
            "                whitespace_after=SimpleWhitespace(\n",
            "                    value='',\n",
            "                ),\n",
            "            ),\n",
            "            rbracket=RightSquareBracket(\n",
            "                whitespace_before=SimpleWhitespace(\n",
            "                    value='',\n",
            "                ),\n",
            "            ),\n",
            "            lpar=[],\n",
            "            rpar=[],\n",
            "            whitespace_after_value=SimpleWhitespace(\n",
            "                value='',\n",
            "            ),\n",
            "        ),\n",
            "        operator=Add(\n",
            "            whitespace_before=SimpleWhitespace(\n",
            "                value=' ',\n",
            "            ),\n",
            "            whitespace_after=SimpleWhitespace(\n",
            "                value=' ',\n",
            "            ),\n",
            "        ),\n",
            "        right=Integer(\n",
            "            value='1',\n",
            "            lpar=[],\n",
            "            rpar=[],\n",
            "        ),\n",
            "        lpar=[],\n",
            "        rpar=[],\n",
            "    ),\n",
            "    operator=Add(\n",
            "        whitespace_before=SimpleWhitespace(\n",
            "            value='',\n",
            "        ),\n",
            "        whitespace_after=SimpleWhitespace(\n",
            "            value='',\n",
            "        ),\n",
            "    ),\n",
            "    right=Subscript(\n",
            "        value=Name(\n",
            "            value='z',\n",
            "            lpar=[],\n",
            "            rpar=[],\n",
            "        ),\n",
            "        slice=[\n",
            "            SubscriptElement(\n",
            "                slice=Slice(\n",
            "                    lower=Integer(\n",
            "                        value='2',\n",
            "                        lpar=[],\n",
            "                        rpar=[],\n",
            "                    ),\n",
            "                    upper=Integer(\n",
            "                        value='10',\n",
            "                        lpar=[],\n",
            "                        rpar=[],\n",
            "                    ),\n",
            "                    step=None,\n",
            "                    first_colon=Colon(\n",
            "                        whitespace_before=SimpleWhitespace(\n",
            "                            value='',\n",
            "                        ),\n",
            "                        whitespace_after=SimpleWhitespace(\n",
            "                            value='',\n",
            "                        ),\n",
            "                    ),\n",
            "                    second_colon=MaybeSentinel.DEFAULT,\n",
            "                ),\n",
            "                comma=MaybeSentinel.DEFAULT,\n",
            "            ),\n",
            "        ],\n",
            "        lbracket=LeftSquareBracket(\n",
            "            whitespace_after=SimpleWhitespace(\n",
            "                value='',\n",
            "            ),\n",
            "        ),\n",
            "        rbracket=RightSquareBracket(\n",
            "            whitespace_before=SimpleWhitespace(\n",
            "                value='',\n",
            "            ),\n",
            "        ),\n",
            "        lpar=[],\n",
            "        rpar=[],\n",
            "        whitespace_after_value=SimpleWhitespace(\n",
            "            value='',\n",
            "        ),\n",
            "    ),\n",
            "    lpar=[],\n",
            "    rpar=[],\n",
            ")\n",
            "Value mismatch in field 'body': [Assign(\n",
            "    targets=[\n",
            "        AssignTarget(\n",
            "            target=Name(\n",
            "                value='x',\n",
            "                lpar=[],\n",
            "                rpar=[],\n",
            "            ),\n",
            "            whitespace_before_equal=SimpleWhitespace(\n",
            "                value=' ',\n",
            "            ),\n",
            "            whitespace_after_equal=SimpleWhitespace(\n",
            "                value=' ',\n",
            "            ),\n",
            "        ),\n",
            "    ],\n",
            "    value=BinaryOperation(\n",
            "        left=BinaryOperation(\n",
            "            left=Subscript(\n",
            "                value=Name(\n",
            "                    value='x',\n",
            "                    lpar=[],\n",
            "                    rpar=[],\n",
            "                ),\n",
            "                slice=[\n",
            "                    SubscriptElement(\n",
            "                        slice=Index(\n",
            "                            value=Integer(\n",
            "                                value='2',\n",
            "                                lpar=[],\n",
            "                                rpar=[],\n",
            "                            ),\n",
            "                            star=None,\n",
            "                            whitespace_after_star=None,\n",
            "                        ),\n",
            "                        comma=MaybeSentinel.DEFAULT,\n",
            "                    ),\n",
            "                ],\n",
            "                lbracket=LeftSquareBracket(\n",
            "                    whitespace_after=SimpleWhitespace(\n",
            "                        value='',\n",
            "                    ),\n",
            "                ),\n",
            "                rbracket=RightSquareBracket(\n",
            "                    whitespace_before=SimpleWhitespace(\n",
            "                        value='',\n",
            "                    ),\n",
            "                ),\n",
            "                lpar=[],\n",
            "                rpar=[],\n",
            "                whitespace_after_value=SimpleWhitespace(\n",
            "                    value='',\n",
            "                ),\n",
            "            ),\n",
            "            operator=Add(\n",
            "                whitespace_before=SimpleWhitespace(\n",
            "                    value=' ',\n",
            "                ),\n",
            "                whitespace_after=SimpleWhitespace(\n",
            "                    value=' ',\n",
            "                ),\n",
            "            ),\n",
            "            right=Integer(\n",
            "                value='1',\n",
            "                lpar=[],\n",
            "                rpar=[],\n",
            "            ),\n",
            "            lpar=[],\n",
            "            rpar=[],\n",
            "        ),\n",
            "        operator=Add(\n",
            "            whitespace_before=SimpleWhitespace(\n",
            "                value='',\n",
            "            ),\n",
            "            whitespace_after=SimpleWhitespace(\n",
            "                value='',\n",
            "            ),\n",
            "        ),\n",
            "        right=Subscript(\n",
            "            value=Name(\n",
            "                value='y',\n",
            "                lpar=[],\n",
            "                rpar=[],\n",
            "            ),\n",
            "            slice=[\n",
            "                SubscriptElement(\n",
            "                    slice=Slice(\n",
            "                        lower=Integer(\n",
            "                            value='2',\n",
            "                            lpar=[],\n",
            "                            rpar=[],\n",
            "                        ),\n",
            "                        upper=Integer(\n",
            "                            value='10',\n",
            "                            lpar=[],\n",
            "                            rpar=[],\n",
            "                        ),\n",
            "                        step=None,\n",
            "                        first_colon=Colon(\n",
            "                            whitespace_before=SimpleWhitespace(\n",
            "                                value='',\n",
            "                            ),\n",
            "                            whitespace_after=SimpleWhitespace(\n",
            "                                value='',\n",
            "                            ),\n",
            "                        ),\n",
            "                        second_colon=MaybeSentinel.DEFAULT,\n",
            "                    ),\n",
            "                    comma=MaybeSentinel.DEFAULT,\n",
            "                ),\n",
            "            ],\n",
            "            lbracket=LeftSquareBracket(\n",
            "                whitespace_after=SimpleWhitespace(\n",
            "                    value='',\n",
            "                ),\n",
            "            ),\n",
            "            rbracket=RightSquareBracket(\n",
            "                whitespace_before=SimpleWhitespace(\n",
            "                    value='',\n",
            "                ),\n",
            "            ),\n",
            "            lpar=[],\n",
            "            rpar=[],\n",
            "            whitespace_after_value=SimpleWhitespace(\n",
            "                value='',\n",
            "            ),\n",
            "        ),\n",
            "        lpar=[],\n",
            "        rpar=[],\n",
            "    ),\n",
            "    semicolon=MaybeSentinel.DEFAULT,\n",
            ")] != [Assign(\n",
            "    targets=[\n",
            "        AssignTarget(\n",
            "            target=Name(\n",
            "                value='x',\n",
            "                lpar=[],\n",
            "                rpar=[],\n",
            "            ),\n",
            "            whitespace_before_equal=SimpleWhitespace(\n",
            "                value=' ',\n",
            "            ),\n",
            "            whitespace_after_equal=SimpleWhitespace(\n",
            "                value=' ',\n",
            "            ),\n",
            "        ),\n",
            "    ],\n",
            "    value=BinaryOperation(\n",
            "        left=BinaryOperation(\n",
            "            left=Subscript(\n",
            "                value=Name(\n",
            "                    value='x',\n",
            "                    lpar=[],\n",
            "                    rpar=[],\n",
            "                ),\n",
            "                slice=[\n",
            "                    SubscriptElement(\n",
            "                        slice=Index(\n",
            "                            value=Integer(\n",
            "                                value='2',\n",
            "                                lpar=[],\n",
            "                                rpar=[],\n",
            "                            ),\n",
            "                            star=None,\n",
            "                            whitespace_after_star=None,\n",
            "                        ),\n",
            "                        comma=MaybeSentinel.DEFAULT,\n",
            "                    ),\n",
            "                ],\n",
            "                lbracket=LeftSquareBracket(\n",
            "                    whitespace_after=SimpleWhitespace(\n",
            "                        value='',\n",
            "                    ),\n",
            "                ),\n",
            "                rbracket=RightSquareBracket(\n",
            "                    whitespace_before=SimpleWhitespace(\n",
            "                        value='',\n",
            "                    ),\n",
            "                ),\n",
            "                lpar=[],\n",
            "                rpar=[],\n",
            "                whitespace_after_value=SimpleWhitespace(\n",
            "                    value='',\n",
            "                ),\n",
            "            ),\n",
            "            operator=Add(\n",
            "                whitespace_before=SimpleWhitespace(\n",
            "                    value=' ',\n",
            "                ),\n",
            "                whitespace_after=SimpleWhitespace(\n",
            "                    value=' ',\n",
            "                ),\n",
            "            ),\n",
            "            right=Integer(\n",
            "                value='1',\n",
            "                lpar=[],\n",
            "                rpar=[],\n",
            "            ),\n",
            "            lpar=[],\n",
            "            rpar=[],\n",
            "        ),\n",
            "        operator=Add(\n",
            "            whitespace_before=SimpleWhitespace(\n",
            "                value='',\n",
            "            ),\n",
            "            whitespace_after=SimpleWhitespace(\n",
            "                value='',\n",
            "            ),\n",
            "        ),\n",
            "        right=Subscript(\n",
            "            value=Name(\n",
            "                value='z',\n",
            "                lpar=[],\n",
            "                rpar=[],\n",
            "            ),\n",
            "            slice=[\n",
            "                SubscriptElement(\n",
            "                    slice=Slice(\n",
            "                        lower=Integer(\n",
            "                            value='2',\n",
            "                            lpar=[],\n",
            "                            rpar=[],\n",
            "                        ),\n",
            "                        upper=Integer(\n",
            "                            value='10',\n",
            "                            lpar=[],\n",
            "                            rpar=[],\n",
            "                        ),\n",
            "                        step=None,\n",
            "                        first_colon=Colon(\n",
            "                            whitespace_before=SimpleWhitespace(\n",
            "                                value='',\n",
            "                            ),\n",
            "                            whitespace_after=SimpleWhitespace(\n",
            "                                value='',\n",
            "                            ),\n",
            "                        ),\n",
            "                        second_colon=MaybeSentinel.DEFAULT,\n",
            "                    ),\n",
            "                    comma=MaybeSentinel.DEFAULT,\n",
            "                ),\n",
            "            ],\n",
            "            lbracket=LeftSquareBracket(\n",
            "                whitespace_after=SimpleWhitespace(\n",
            "                    value='',\n",
            "                ),\n",
            "            ),\n",
            "            rbracket=RightSquareBracket(\n",
            "                whitespace_before=SimpleWhitespace(\n",
            "                    value='',\n",
            "                ),\n",
            "            ),\n",
            "            lpar=[],\n",
            "            rpar=[],\n",
            "            whitespace_after_value=SimpleWhitespace(\n",
            "                value='',\n",
            "            ),\n",
            "        ),\n",
            "        lpar=[],\n",
            "        rpar=[],\n",
            "    ),\n",
            "    semicolon=MaybeSentinel.DEFAULT,\n",
            ")]\n",
            "Value mismatch in field 'body': [SimpleStatementLine(\n",
            "    body=[\n",
            "        Expr(\n",
            "            value=Call(\n",
            "                func=Name(\n",
            "                    value='print',\n",
            "                    lpar=[],\n",
            "                    rpar=[],\n",
            "                ),\n",
            "                args=[\n",
            "                    Arg(\n",
            "                        value=Name(\n",
            "                            value='x',\n",
            "                            lpar=[],\n",
            "                            rpar=[],\n",
            "                        ),\n",
            "                        keyword=None,\n",
            "                        equal=MaybeSentinel.DEFAULT,\n",
            "                        comma=MaybeSentinel.DEFAULT,\n",
            "                        star='',\n",
            "                        whitespace_after_star=SimpleWhitespace(\n",
            "                            value='',\n",
            "                        ),\n",
            "                        whitespace_after_arg=SimpleWhitespace(\n",
            "                            value='',\n",
            "                        ),\n",
            "                    ),\n",
            "                ],\n",
            "                lpar=[],\n",
            "                rpar=[],\n",
            "                whitespace_after_func=SimpleWhitespace(\n",
            "                    value='',\n",
            "                ),\n",
            "                whitespace_before_args=SimpleWhitespace(\n",
            "                    value='',\n",
            "                ),\n",
            "            ),\n",
            "            semicolon=MaybeSentinel.DEFAULT,\n",
            "        ),\n",
            "    ],\n",
            "    leading_lines=[],\n",
            "    trailing_whitespace=TrailingWhitespace(\n",
            "        whitespace=SimpleWhitespace(\n",
            "            value='',\n",
            "        ),\n",
            "        comment=None,\n",
            "        newline=Newline(\n",
            "            value=None,\n",
            "        ),\n",
            "    ),\n",
            "), SimpleStatementLine(\n",
            "    body=[\n",
            "        Assign(\n",
            "            targets=[\n",
            "                AssignTarget(\n",
            "                    target=Name(\n",
            "                        value='x',\n",
            "                        lpar=[],\n",
            "                        rpar=[],\n",
            "                    ),\n",
            "                    whitespace_before_equal=SimpleWhitespace(\n",
            "                        value=' ',\n",
            "                    ),\n",
            "                    whitespace_after_equal=SimpleWhitespace(\n",
            "                        value=' ',\n",
            "                    ),\n",
            "                ),\n",
            "            ],\n",
            "            value=BinaryOperation(\n",
            "                left=BinaryOperation(\n",
            "                    left=Subscript(\n",
            "                        value=Name(\n",
            "                            value='x',\n",
            "                            lpar=[],\n",
            "                            rpar=[],\n",
            "                        ),\n",
            "                        slice=[\n",
            "                            SubscriptElement(\n",
            "                                slice=Index(\n",
            "                                    value=Integer(\n",
            "                                        value='2',\n",
            "                                        lpar=[],\n",
            "                                        rpar=[],\n",
            "                                    ),\n",
            "                                    star=None,\n",
            "                                    whitespace_after_star=None,\n",
            "                                ),\n",
            "                                comma=MaybeSentinel.DEFAULT,\n",
            "                            ),\n",
            "                        ],\n",
            "                        lbracket=LeftSquareBracket(\n",
            "                            whitespace_after=SimpleWhitespace(\n",
            "                                value='',\n",
            "                            ),\n",
            "                        ),\n",
            "                        rbracket=RightSquareBracket(\n",
            "                            whitespace_before=SimpleWhitespace(\n",
            "                                value='',\n",
            "                            ),\n",
            "                        ),\n",
            "                        lpar=[],\n",
            "                        rpar=[],\n",
            "                        whitespace_after_value=SimpleWhitespace(\n",
            "                            value='',\n",
            "                        ),\n",
            "                    ),\n",
            "                    operator=Add(\n",
            "                        whitespace_before=SimpleWhitespace(\n",
            "                            value=' ',\n",
            "                        ),\n",
            "                        whitespace_after=SimpleWhitespace(\n",
            "                            value=' ',\n",
            "                        ),\n",
            "                    ),\n",
            "                    right=Integer(\n",
            "                        value='1',\n",
            "                        lpar=[],\n",
            "                        rpar=[],\n",
            "                    ),\n",
            "                    lpar=[],\n",
            "                    rpar=[],\n",
            "                ),\n",
            "                operator=Add(\n",
            "                    whitespace_before=SimpleWhitespace(\n",
            "                        value='',\n",
            "                    ),\n",
            "                    whitespace_after=SimpleWhitespace(\n",
            "                        value='',\n",
            "                    ),\n",
            "                ),\n",
            "                right=Subscript(\n",
            "                    value=Name(\n",
            "                        value='y',\n",
            "                        lpar=[],\n",
            "                        rpar=[],\n",
            "                    ),\n",
            "                    slice=[\n",
            "                        SubscriptElement(\n",
            "                            slice=Slice(\n",
            "                                lower=Integer(\n",
            "                                    value='2',\n",
            "                                    lpar=[],\n",
            "                                    rpar=[],\n",
            "                                ),\n",
            "                                upper=Integer(\n",
            "                                    value='10',\n",
            "                                    lpar=[],\n",
            "                                    rpar=[],\n",
            "                                ),\n",
            "                                step=None,\n",
            "                                first_colon=Colon(\n",
            "                                    whitespace_before=SimpleWhitespace(\n",
            "                                        value='',\n",
            "                                    ),\n",
            "                                    whitespace_after=SimpleWhitespace(\n",
            "                                        value='',\n",
            "                                    ),\n",
            "                                ),\n",
            "                                second_colon=MaybeSentinel.DEFAULT,\n",
            "                            ),\n",
            "                            comma=MaybeSentinel.DEFAULT,\n",
            "                        ),\n",
            "                    ],\n",
            "                    lbracket=LeftSquareBracket(\n",
            "                        whitespace_after=SimpleWhitespace(\n",
            "                            value='',\n",
            "                        ),\n",
            "                    ),\n",
            "                    rbracket=RightSquareBracket(\n",
            "                        whitespace_before=SimpleWhitespace(\n",
            "                            value='',\n",
            "                        ),\n",
            "                    ),\n",
            "                    lpar=[],\n",
            "                    rpar=[],\n",
            "                    whitespace_after_value=SimpleWhitespace(\n",
            "                        value='',\n",
            "                    ),\n",
            "                ),\n",
            "                lpar=[],\n",
            "                rpar=[],\n",
            "            ),\n",
            "            semicolon=MaybeSentinel.DEFAULT,\n",
            "        ),\n",
            "    ],\n",
            "    leading_lines=[],\n",
            "    trailing_whitespace=TrailingWhitespace(\n",
            "        whitespace=SimpleWhitespace(\n",
            "            value='',\n",
            "        ),\n",
            "        comment=None,\n",
            "        newline=Newline(\n",
            "            value=None,\n",
            "        ),\n",
            "    ),\n",
            ")] != [SimpleStatementLine(\n",
            "    body=[\n",
            "        Expr(\n",
            "            value=Call(\n",
            "                func=Name(\n",
            "                    value='print',\n",
            "                    lpar=[],\n",
            "                    rpar=[],\n",
            "                ),\n",
            "                args=[\n",
            "                    Arg(\n",
            "                        value=Name(\n",
            "                            value='x',\n",
            "                            lpar=[],\n",
            "                            rpar=[],\n",
            "                        ),\n",
            "                        keyword=None,\n",
            "                        equal=MaybeSentinel.DEFAULT,\n",
            "                        comma=MaybeSentinel.DEFAULT,\n",
            "                        star='',\n",
            "                        whitespace_after_star=SimpleWhitespace(\n",
            "                            value='',\n",
            "                        ),\n",
            "                        whitespace_after_arg=SimpleWhitespace(\n",
            "                            value='',\n",
            "                        ),\n",
            "                    ),\n",
            "                ],\n",
            "                lpar=[],\n",
            "                rpar=[],\n",
            "                whitespace_after_func=SimpleWhitespace(\n",
            "                    value='',\n",
            "                ),\n",
            "                whitespace_before_args=SimpleWhitespace(\n",
            "                    value='',\n",
            "                ),\n",
            "            ),\n",
            "            semicolon=MaybeSentinel.DEFAULT,\n",
            "        ),\n",
            "    ],\n",
            "    leading_lines=[],\n",
            "    trailing_whitespace=TrailingWhitespace(\n",
            "        whitespace=SimpleWhitespace(\n",
            "            value='',\n",
            "        ),\n",
            "        comment=None,\n",
            "        newline=Newline(\n",
            "            value=None,\n",
            "        ),\n",
            "    ),\n",
            "), SimpleStatementLine(\n",
            "    body=[\n",
            "        Assign(\n",
            "            targets=[\n",
            "                AssignTarget(\n",
            "                    target=Name(\n",
            "                        value='x',\n",
            "                        lpar=[],\n",
            "                        rpar=[],\n",
            "                    ),\n",
            "                    whitespace_before_equal=SimpleWhitespace(\n",
            "                        value=' ',\n",
            "                    ),\n",
            "                    whitespace_after_equal=SimpleWhitespace(\n",
            "                        value=' ',\n",
            "                    ),\n",
            "                ),\n",
            "            ],\n",
            "            value=BinaryOperation(\n",
            "                left=BinaryOperation(\n",
            "                    left=Subscript(\n",
            "                        value=Name(\n",
            "                            value='x',\n",
            "                            lpar=[],\n",
            "                            rpar=[],\n",
            "                        ),\n",
            "                        slice=[\n",
            "                            SubscriptElement(\n",
            "                                slice=Index(\n",
            "                                    value=Integer(\n",
            "                                        value='2',\n",
            "                                        lpar=[],\n",
            "                                        rpar=[],\n",
            "                                    ),\n",
            "                                    star=None,\n",
            "                                    whitespace_after_star=None,\n",
            "                                ),\n",
            "                                comma=MaybeSentinel.DEFAULT,\n",
            "                            ),\n",
            "                        ],\n",
            "                        lbracket=LeftSquareBracket(\n",
            "                            whitespace_after=SimpleWhitespace(\n",
            "                                value='',\n",
            "                            ),\n",
            "                        ),\n",
            "                        rbracket=RightSquareBracket(\n",
            "                            whitespace_before=SimpleWhitespace(\n",
            "                                value='',\n",
            "                            ),\n",
            "                        ),\n",
            "                        lpar=[],\n",
            "                        rpar=[],\n",
            "                        whitespace_after_value=SimpleWhitespace(\n",
            "                            value='',\n",
            "                        ),\n",
            "                    ),\n",
            "                    operator=Add(\n",
            "                        whitespace_before=SimpleWhitespace(\n",
            "                            value=' ',\n",
            "                        ),\n",
            "                        whitespace_after=SimpleWhitespace(\n",
            "                            value=' ',\n",
            "                        ),\n",
            "                    ),\n",
            "                    right=Integer(\n",
            "                        value='1',\n",
            "                        lpar=[],\n",
            "                        rpar=[],\n",
            "                    ),\n",
            "                    lpar=[],\n",
            "                    rpar=[],\n",
            "                ),\n",
            "                operator=Add(\n",
            "                    whitespace_before=SimpleWhitespace(\n",
            "                        value='',\n",
            "                    ),\n",
            "                    whitespace_after=SimpleWhitespace(\n",
            "                        value='',\n",
            "                    ),\n",
            "                ),\n",
            "                right=Subscript(\n",
            "                    value=Name(\n",
            "                        value='z',\n",
            "                        lpar=[],\n",
            "                        rpar=[],\n",
            "                    ),\n",
            "                    slice=[\n",
            "                        SubscriptElement(\n",
            "                            slice=Slice(\n",
            "                                lower=Integer(\n",
            "                                    value='2',\n",
            "                                    lpar=[],\n",
            "                                    rpar=[],\n",
            "                                ),\n",
            "                                upper=Integer(\n",
            "                                    value='10',\n",
            "                                    lpar=[],\n",
            "                                    rpar=[],\n",
            "                                ),\n",
            "                                step=None,\n",
            "                                first_colon=Colon(\n",
            "                                    whitespace_before=SimpleWhitespace(\n",
            "                                        value='',\n",
            "                                    ),\n",
            "                                    whitespace_after=SimpleWhitespace(\n",
            "                                        value='',\n",
            "                                    ),\n",
            "                                ),\n",
            "                                second_colon=MaybeSentinel.DEFAULT,\n",
            "                            ),\n",
            "                            comma=MaybeSentinel.DEFAULT,\n",
            "                        ),\n",
            "                    ],\n",
            "                    lbracket=LeftSquareBracket(\n",
            "                        whitespace_after=SimpleWhitespace(\n",
            "                            value='',\n",
            "                        ),\n",
            "                    ),\n",
            "                    rbracket=RightSquareBracket(\n",
            "                        whitespace_before=SimpleWhitespace(\n",
            "                            value='',\n",
            "                        ),\n",
            "                    ),\n",
            "                    lpar=[],\n",
            "                    rpar=[],\n",
            "                    whitespace_after_value=SimpleWhitespace(\n",
            "                        value='',\n",
            "                    ),\n",
            "                ),\n",
            "                lpar=[],\n",
            "                rpar=[],\n",
            "            ),\n",
            "            semicolon=MaybeSentinel.DEFAULT,\n",
            "        ),\n",
            "    ],\n",
            "    leading_lines=[],\n",
            "    trailing_whitespace=TrailingWhitespace(\n",
            "        whitespace=SimpleWhitespace(\n",
            "            value='',\n",
            "        ),\n",
            "        comment=None,\n",
            "        newline=Newline(\n",
            "            value=None,\n",
            "        ),\n",
            "    ),\n",
            ")]\n",
            "Value mismatch in field 'body': IndentedBlock(\n",
            "    body=[\n",
            "        SimpleStatementLine(\n",
            "            body=[\n",
            "                Expr(\n",
            "                    value=Call(\n",
            "                        func=Name(\n",
            "                            value='print',\n",
            "                            lpar=[],\n",
            "                            rpar=[],\n",
            "                        ),\n",
            "                        args=[\n",
            "                            Arg(\n",
            "                                value=Name(\n",
            "                                    value='x',\n",
            "                                    lpar=[],\n",
            "                                    rpar=[],\n",
            "                                ),\n",
            "                                keyword=None,\n",
            "                                equal=MaybeSentinel.DEFAULT,\n",
            "                                comma=MaybeSentinel.DEFAULT,\n",
            "                                star='',\n",
            "                                whitespace_after_star=SimpleWhitespace(\n",
            "                                    value='',\n",
            "                                ),\n",
            "                                whitespace_after_arg=SimpleWhitespace(\n",
            "                                    value='',\n",
            "                                ),\n",
            "                            ),\n",
            "                        ],\n",
            "                        lpar=[],\n",
            "                        rpar=[],\n",
            "                        whitespace_after_func=SimpleWhitespace(\n",
            "                            value='',\n",
            "                        ),\n",
            "                        whitespace_before_args=SimpleWhitespace(\n",
            "                            value='',\n",
            "                        ),\n",
            "                    ),\n",
            "                    semicolon=MaybeSentinel.DEFAULT,\n",
            "                ),\n",
            "            ],\n",
            "            leading_lines=[],\n",
            "            trailing_whitespace=TrailingWhitespace(\n",
            "                whitespace=SimpleWhitespace(\n",
            "                    value='',\n",
            "                ),\n",
            "                comment=None,\n",
            "                newline=Newline(\n",
            "                    value=None,\n",
            "                ),\n",
            "            ),\n",
            "        ),\n",
            "        SimpleStatementLine(\n",
            "            body=[\n",
            "                Assign(\n",
            "                    targets=[\n",
            "                        AssignTarget(\n",
            "                            target=Name(\n",
            "                                value='x',\n",
            "                                lpar=[],\n",
            "                                rpar=[],\n",
            "                            ),\n",
            "                            whitespace_before_equal=SimpleWhitespace(\n",
            "                                value=' ',\n",
            "                            ),\n",
            "                            whitespace_after_equal=SimpleWhitespace(\n",
            "                                value=' ',\n",
            "                            ),\n",
            "                        ),\n",
            "                    ],\n",
            "                    value=BinaryOperation(\n",
            "                        left=BinaryOperation(\n",
            "                            left=Subscript(\n",
            "                                value=Name(\n",
            "                                    value='x',\n",
            "                                    lpar=[],\n",
            "                                    rpar=[],\n",
            "                                ),\n",
            "                                slice=[\n",
            "                                    SubscriptElement(\n",
            "                                        slice=Index(\n",
            "                                            value=Integer(\n",
            "                                                value='2',\n",
            "                                                lpar=[],\n",
            "                                                rpar=[],\n",
            "                                            ),\n",
            "                                            star=None,\n",
            "                                            whitespace_after_star=None,\n",
            "                                        ),\n",
            "                                        comma=MaybeSentinel.DEFAULT,\n",
            "                                    ),\n",
            "                                ],\n",
            "                                lbracket=LeftSquareBracket(\n",
            "                                    whitespace_after=SimpleWhitespace(\n",
            "                                        value='',\n",
            "                                    ),\n",
            "                                ),\n",
            "                                rbracket=RightSquareBracket(\n",
            "                                    whitespace_before=SimpleWhitespace(\n",
            "                                        value='',\n",
            "                                    ),\n",
            "                                ),\n",
            "                                lpar=[],\n",
            "                                rpar=[],\n",
            "                                whitespace_after_value=SimpleWhitespace(\n",
            "                                    value='',\n",
            "                                ),\n",
            "                            ),\n",
            "                            operator=Add(\n",
            "                                whitespace_before=SimpleWhitespace(\n",
            "                                    value=' ',\n",
            "                                ),\n",
            "                                whitespace_after=SimpleWhitespace(\n",
            "                                    value=' ',\n",
            "                                ),\n",
            "                            ),\n",
            "                            right=Integer(\n",
            "                                value='1',\n",
            "                                lpar=[],\n",
            "                                rpar=[],\n",
            "                            ),\n",
            "                            lpar=[],\n",
            "                            rpar=[],\n",
            "                        ),\n",
            "                        operator=Add(\n",
            "                            whitespace_before=SimpleWhitespace(\n",
            "                                value='',\n",
            "                            ),\n",
            "                            whitespace_after=SimpleWhitespace(\n",
            "                                value='',\n",
            "                            ),\n",
            "                        ),\n",
            "                        right=Subscript(\n",
            "                            value=Name(\n",
            "                                value='y',\n",
            "                                lpar=[],\n",
            "                                rpar=[],\n",
            "                            ),\n",
            "                            slice=[\n",
            "                                SubscriptElement(\n",
            "                                    slice=Slice(\n",
            "                                        lower=Integer(\n",
            "                                            value='2',\n",
            "                                            lpar=[],\n",
            "                                            rpar=[],\n",
            "                                        ),\n",
            "                                        upper=Integer(\n",
            "                                            value='10',\n",
            "                                            lpar=[],\n",
            "                                            rpar=[],\n",
            "                                        ),\n",
            "                                        step=None,\n",
            "                                        first_colon=Colon(\n",
            "                                            whitespace_before=SimpleWhitespace(\n",
            "                                                value='',\n",
            "                                            ),\n",
            "                                            whitespace_after=SimpleWhitespace(\n",
            "                                                value='',\n",
            "                                            ),\n",
            "                                        ),\n",
            "                                        second_colon=MaybeSentinel.DEFAULT,\n",
            "                                    ),\n",
            "                                    comma=MaybeSentinel.DEFAULT,\n",
            "                                ),\n",
            "                            ],\n",
            "                            lbracket=LeftSquareBracket(\n",
            "                                whitespace_after=SimpleWhitespace(\n",
            "                                    value='',\n",
            "                                ),\n",
            "                            ),\n",
            "                            rbracket=RightSquareBracket(\n",
            "                                whitespace_before=SimpleWhitespace(\n",
            "                                    value='',\n",
            "                                ),\n",
            "                            ),\n",
            "                            lpar=[],\n",
            "                            rpar=[],\n",
            "                            whitespace_after_value=SimpleWhitespace(\n",
            "                                value='',\n",
            "                            ),\n",
            "                        ),\n",
            "                        lpar=[],\n",
            "                        rpar=[],\n",
            "                    ),\n",
            "                    semicolon=MaybeSentinel.DEFAULT,\n",
            "                ),\n",
            "            ],\n",
            "            leading_lines=[],\n",
            "            trailing_whitespace=TrailingWhitespace(\n",
            "                whitespace=SimpleWhitespace(\n",
            "                    value='',\n",
            "                ),\n",
            "                comment=None,\n",
            "                newline=Newline(\n",
            "                    value=None,\n",
            "                ),\n",
            "            ),\n",
            "        ),\n",
            "    ],\n",
            "    header=TrailingWhitespace(\n",
            "        whitespace=SimpleWhitespace(\n",
            "            value='',\n",
            "        ),\n",
            "        comment=None,\n",
            "        newline=Newline(\n",
            "            value=None,\n",
            "        ),\n",
            "    ),\n",
            "    indent=None,\n",
            "    footer=[],\n",
            ") != IndentedBlock(\n",
            "    body=[\n",
            "        SimpleStatementLine(\n",
            "            body=[\n",
            "                Expr(\n",
            "                    value=Call(\n",
            "                        func=Name(\n",
            "                            value='print',\n",
            "                            lpar=[],\n",
            "                            rpar=[],\n",
            "                        ),\n",
            "                        args=[\n",
            "                            Arg(\n",
            "                                value=Name(\n",
            "                                    value='x',\n",
            "                                    lpar=[],\n",
            "                                    rpar=[],\n",
            "                                ),\n",
            "                                keyword=None,\n",
            "                                equal=MaybeSentinel.DEFAULT,\n",
            "                                comma=MaybeSentinel.DEFAULT,\n",
            "                                star='',\n",
            "                                whitespace_after_star=SimpleWhitespace(\n",
            "                                    value='',\n",
            "                                ),\n",
            "                                whitespace_after_arg=SimpleWhitespace(\n",
            "                                    value='',\n",
            "                                ),\n",
            "                            ),\n",
            "                        ],\n",
            "                        lpar=[],\n",
            "                        rpar=[],\n",
            "                        whitespace_after_func=SimpleWhitespace(\n",
            "                            value='',\n",
            "                        ),\n",
            "                        whitespace_before_args=SimpleWhitespace(\n",
            "                            value='',\n",
            "                        ),\n",
            "                    ),\n",
            "                    semicolon=MaybeSentinel.DEFAULT,\n",
            "                ),\n",
            "            ],\n",
            "            leading_lines=[],\n",
            "            trailing_whitespace=TrailingWhitespace(\n",
            "                whitespace=SimpleWhitespace(\n",
            "                    value='',\n",
            "                ),\n",
            "                comment=None,\n",
            "                newline=Newline(\n",
            "                    value=None,\n",
            "                ),\n",
            "            ),\n",
            "        ),\n",
            "        SimpleStatementLine(\n",
            "            body=[\n",
            "                Assign(\n",
            "                    targets=[\n",
            "                        AssignTarget(\n",
            "                            target=Name(\n",
            "                                value='x',\n",
            "                                lpar=[],\n",
            "                                rpar=[],\n",
            "                            ),\n",
            "                            whitespace_before_equal=SimpleWhitespace(\n",
            "                                value=' ',\n",
            "                            ),\n",
            "                            whitespace_after_equal=SimpleWhitespace(\n",
            "                                value=' ',\n",
            "                            ),\n",
            "                        ),\n",
            "                    ],\n",
            "                    value=BinaryOperation(\n",
            "                        left=BinaryOperation(\n",
            "                            left=Subscript(\n",
            "                                value=Name(\n",
            "                                    value='x',\n",
            "                                    lpar=[],\n",
            "                                    rpar=[],\n",
            "                                ),\n",
            "                                slice=[\n",
            "                                    SubscriptElement(\n",
            "                                        slice=Index(\n",
            "                                            value=Integer(\n",
            "                                                value='2',\n",
            "                                                lpar=[],\n",
            "                                                rpar=[],\n",
            "                                            ),\n",
            "                                            star=None,\n",
            "                                            whitespace_after_star=None,\n",
            "                                        ),\n",
            "                                        comma=MaybeSentinel.DEFAULT,\n",
            "                                    ),\n",
            "                                ],\n",
            "                                lbracket=LeftSquareBracket(\n",
            "                                    whitespace_after=SimpleWhitespace(\n",
            "                                        value='',\n",
            "                                    ),\n",
            "                                ),\n",
            "                                rbracket=RightSquareBracket(\n",
            "                                    whitespace_before=SimpleWhitespace(\n",
            "                                        value='',\n",
            "                                    ),\n",
            "                                ),\n",
            "                                lpar=[],\n",
            "                                rpar=[],\n",
            "                                whitespace_after_value=SimpleWhitespace(\n",
            "                                    value='',\n",
            "                                ),\n",
            "                            ),\n",
            "                            operator=Add(\n",
            "                                whitespace_before=SimpleWhitespace(\n",
            "                                    value=' ',\n",
            "                                ),\n",
            "                                whitespace_after=SimpleWhitespace(\n",
            "                                    value=' ',\n",
            "                                ),\n",
            "                            ),\n",
            "                            right=Integer(\n",
            "                                value='1',\n",
            "                                lpar=[],\n",
            "                                rpar=[],\n",
            "                            ),\n",
            "                            lpar=[],\n",
            "                            rpar=[],\n",
            "                        ),\n",
            "                        operator=Add(\n",
            "                            whitespace_before=SimpleWhitespace(\n",
            "                                value='',\n",
            "                            ),\n",
            "                            whitespace_after=SimpleWhitespace(\n",
            "                                value='',\n",
            "                            ),\n",
            "                        ),\n",
            "                        right=Subscript(\n",
            "                            value=Name(\n",
            "                                value='z',\n",
            "                                lpar=[],\n",
            "                                rpar=[],\n",
            "                            ),\n",
            "                            slice=[\n",
            "                                SubscriptElement(\n",
            "                                    slice=Slice(\n",
            "                                        lower=Integer(\n",
            "                                            value='2',\n",
            "                                            lpar=[],\n",
            "                                            rpar=[],\n",
            "                                        ),\n",
            "                                        upper=Integer(\n",
            "                                            value='10',\n",
            "                                            lpar=[],\n",
            "                                            rpar=[],\n",
            "                                        ),\n",
            "                                        step=None,\n",
            "                                        first_colon=Colon(\n",
            "                                            whitespace_before=SimpleWhitespace(\n",
            "                                                value='',\n",
            "                                            ),\n",
            "                                            whitespace_after=SimpleWhitespace(\n",
            "                                                value='',\n",
            "                                            ),\n",
            "                                        ),\n",
            "                                        second_colon=MaybeSentinel.DEFAULT,\n",
            "                                    ),\n",
            "                                    comma=MaybeSentinel.DEFAULT,\n",
            "                                ),\n",
            "                            ],\n",
            "                            lbracket=LeftSquareBracket(\n",
            "                                whitespace_after=SimpleWhitespace(\n",
            "                                    value='',\n",
            "                                ),\n",
            "                            ),\n",
            "                            rbracket=RightSquareBracket(\n",
            "                                whitespace_before=SimpleWhitespace(\n",
            "                                    value='',\n",
            "                                ),\n",
            "                            ),\n",
            "                            lpar=[],\n",
            "                            rpar=[],\n",
            "                            whitespace_after_value=SimpleWhitespace(\n",
            "                                value='',\n",
            "                            ),\n",
            "                        ),\n",
            "                        lpar=[],\n",
            "                        rpar=[],\n",
            "                    ),\n",
            "                    semicolon=MaybeSentinel.DEFAULT,\n",
            "                ),\n",
            "            ],\n",
            "            leading_lines=[],\n",
            "            trailing_whitespace=TrailingWhitespace(\n",
            "                whitespace=SimpleWhitespace(\n",
            "                    value='',\n",
            "                ),\n",
            "                comment=None,\n",
            "                newline=Newline(\n",
            "                    value=None,\n",
            "                ),\n",
            "            ),\n",
            "        ),\n",
            "    ],\n",
            "    header=TrailingWhitespace(\n",
            "        whitespace=SimpleWhitespace(\n",
            "            value='',\n",
            "        ),\n",
            "        comment=None,\n",
            "        newline=Newline(\n",
            "            value=None,\n",
            "        ),\n",
            "    ),\n",
            "    indent=None,\n",
            "    footer=[],\n",
            ")\n",
            "Value mismatch in field 'body': [While(\n",
            "    test=Comparison(\n",
            "        left=Name(\n",
            "            value='x',\n",
            "            lpar=[],\n",
            "            rpar=[],\n",
            "        ),\n",
            "        comparisons=[\n",
            "            ComparisonTarget(\n",
            "                operator=LessThan(\n",
            "                    whitespace_before=SimpleWhitespace(\n",
            "                        value=' ',\n",
            "                    ),\n",
            "                    whitespace_after=SimpleWhitespace(\n",
            "                        value=' ',\n",
            "                    ),\n",
            "                ),\n",
            "                comparator=Subscript(\n",
            "                    value=Name(\n",
            "                        value='y',\n",
            "                        lpar=[],\n",
            "                        rpar=[],\n",
            "                    ),\n",
            "                    slice=[\n",
            "                        SubscriptElement(\n",
            "                            slice=Index(\n",
            "                                value=Integer(\n",
            "                                    value='10',\n",
            "                                    lpar=[],\n",
            "                                    rpar=[],\n",
            "                                ),\n",
            "                                star=None,\n",
            "                                whitespace_after_star=None,\n",
            "                            ),\n",
            "                            comma=MaybeSentinel.DEFAULT,\n",
            "                        ),\n",
            "                    ],\n",
            "                    lbracket=LeftSquareBracket(\n",
            "                        whitespace_after=SimpleWhitespace(\n",
            "                            value='',\n",
            "                        ),\n",
            "                    ),\n",
            "                    rbracket=RightSquareBracket(\n",
            "                        whitespace_before=SimpleWhitespace(\n",
            "                            value='',\n",
            "                        ),\n",
            "                    ),\n",
            "                    lpar=[],\n",
            "                    rpar=[],\n",
            "                    whitespace_after_value=SimpleWhitespace(\n",
            "                        value='',\n",
            "                    ),\n",
            "                ),\n",
            "            ),\n",
            "        ],\n",
            "        lpar=[],\n",
            "        rpar=[],\n",
            "    ),\n",
            "    body=IndentedBlock(\n",
            "        body=[\n",
            "            SimpleStatementLine(\n",
            "                body=[\n",
            "                    Expr(\n",
            "                        value=Call(\n",
            "                            func=Name(\n",
            "                                value='print',\n",
            "                                lpar=[],\n",
            "                                rpar=[],\n",
            "                            ),\n",
            "                            args=[\n",
            "                                Arg(\n",
            "                                    value=Name(\n",
            "                                        value='x',\n",
            "                                        lpar=[],\n",
            "                                        rpar=[],\n",
            "                                    ),\n",
            "                                    keyword=None,\n",
            "                                    equal=MaybeSentinel.DEFAULT,\n",
            "                                    comma=MaybeSentinel.DEFAULT,\n",
            "                                    star='',\n",
            "                                    whitespace_after_star=SimpleWhitespace(\n",
            "                                        value='',\n",
            "                                    ),\n",
            "                                    whitespace_after_arg=SimpleWhitespace(\n",
            "                                        value='',\n",
            "                                    ),\n",
            "                                ),\n",
            "                            ],\n",
            "                            lpar=[],\n",
            "                            rpar=[],\n",
            "                            whitespace_after_func=SimpleWhitespace(\n",
            "                                value='',\n",
            "                            ),\n",
            "                            whitespace_before_args=SimpleWhitespace(\n",
            "                                value='',\n",
            "                            ),\n",
            "                        ),\n",
            "                        semicolon=MaybeSentinel.DEFAULT,\n",
            "                    ),\n",
            "                ],\n",
            "                leading_lines=[],\n",
            "                trailing_whitespace=TrailingWhitespace(\n",
            "                    whitespace=SimpleWhitespace(\n",
            "                        value='',\n",
            "                    ),\n",
            "                    comment=None,\n",
            "                    newline=Newline(\n",
            "                        value=None,\n",
            "                    ),\n",
            "                ),\n",
            "            ),\n",
            "            SimpleStatementLine(\n",
            "                body=[\n",
            "                    Assign(\n",
            "                        targets=[\n",
            "                            AssignTarget(\n",
            "                                target=Name(\n",
            "                                    value='x',\n",
            "                                    lpar=[],\n",
            "                                    rpar=[],\n",
            "                                ),\n",
            "                                whitespace_before_equal=SimpleWhitespace(\n",
            "                                    value=' ',\n",
            "                                ),\n",
            "                                whitespace_after_equal=SimpleWhitespace(\n",
            "                                    value=' ',\n",
            "                                ),\n",
            "                            ),\n",
            "                        ],\n",
            "                        value=BinaryOperation(\n",
            "                            left=BinaryOperation(\n",
            "                                left=Subscript(\n",
            "                                    value=Name(\n",
            "                                        value='x',\n",
            "                                        lpar=[],\n",
            "                                        rpar=[],\n",
            "                                    ),\n",
            "                                    slice=[\n",
            "                                        SubscriptElement(\n",
            "                                            slice=Index(\n",
            "                                                value=Integer(\n",
            "                                                    value='2',\n",
            "                                                    lpar=[],\n",
            "                                                    rpar=[],\n",
            "                                                ),\n",
            "                                                star=None,\n",
            "                                                whitespace_after_star=None,\n",
            "                                            ),\n",
            "                                            comma=MaybeSentinel.DEFAULT,\n",
            "                                        ),\n",
            "                                    ],\n",
            "                                    lbracket=LeftSquareBracket(\n",
            "                                        whitespace_after=SimpleWhitespace(\n",
            "                                            value='',\n",
            "                                        ),\n",
            "                                    ),\n",
            "                                    rbracket=RightSquareBracket(\n",
            "                                        whitespace_before=SimpleWhitespace(\n",
            "                                            value='',\n",
            "                                        ),\n",
            "                                    ),\n",
            "                                    lpar=[],\n",
            "                                    rpar=[],\n",
            "                                    whitespace_after_value=SimpleWhitespace(\n",
            "                                        value='',\n",
            "                                    ),\n",
            "                                ),\n",
            "                                operator=Add(\n",
            "                                    whitespace_before=SimpleWhitespace(\n",
            "                                        value=' ',\n",
            "                                    ),\n",
            "                                    whitespace_after=SimpleWhitespace(\n",
            "                                        value=' ',\n",
            "                                    ),\n",
            "                                ),\n",
            "                                right=Integer(\n",
            "                                    value='1',\n",
            "                                    lpar=[],\n",
            "                                    rpar=[],\n",
            "                                ),\n",
            "                                lpar=[],\n",
            "                                rpar=[],\n",
            "                            ),\n",
            "                            operator=Add(\n",
            "                                whitespace_before=SimpleWhitespace(\n",
            "                                    value='',\n",
            "                                ),\n",
            "                                whitespace_after=SimpleWhitespace(\n",
            "                                    value='',\n",
            "                                ),\n",
            "                            ),\n",
            "                            right=Subscript(\n",
            "                                value=Name(\n",
            "                                    value='y',\n",
            "                                    lpar=[],\n",
            "                                    rpar=[],\n",
            "                                ),\n",
            "                                slice=[\n",
            "                                    SubscriptElement(\n",
            "                                        slice=Slice(\n",
            "                                            lower=Integer(\n",
            "                                                value='2',\n",
            "                                                lpar=[],\n",
            "                                                rpar=[],\n",
            "                                            ),\n",
            "                                            upper=Integer(\n",
            "                                                value='10',\n",
            "                                                lpar=[],\n",
            "                                                rpar=[],\n",
            "                                            ),\n",
            "                                            step=None,\n",
            "                                            first_colon=Colon(\n",
            "                                                whitespace_before=SimpleWhitespace(\n",
            "                                                    value='',\n",
            "                                                ),\n",
            "                                                whitespace_after=SimpleWhitespace(\n",
            "                                                    value='',\n",
            "                                                ),\n",
            "                                            ),\n",
            "                                            second_colon=MaybeSentinel.DEFAULT,\n",
            "                                        ),\n",
            "                                        comma=MaybeSentinel.DEFAULT,\n",
            "                                    ),\n",
            "                                ],\n",
            "                                lbracket=LeftSquareBracket(\n",
            "                                    whitespace_after=SimpleWhitespace(\n",
            "                                        value='',\n",
            "                                    ),\n",
            "                                ),\n",
            "                                rbracket=RightSquareBracket(\n",
            "                                    whitespace_before=SimpleWhitespace(\n",
            "                                        value='',\n",
            "                                    ),\n",
            "                                ),\n",
            "                                lpar=[],\n",
            "                                rpar=[],\n",
            "                                whitespace_after_value=SimpleWhitespace(\n",
            "                                    value='',\n",
            "                                ),\n",
            "                            ),\n",
            "                            lpar=[],\n",
            "                            rpar=[],\n",
            "                        ),\n",
            "                        semicolon=MaybeSentinel.DEFAULT,\n",
            "                    ),\n",
            "                ],\n",
            "                leading_lines=[],\n",
            "                trailing_whitespace=TrailingWhitespace(\n",
            "                    whitespace=SimpleWhitespace(\n",
            "                        value='',\n",
            "                    ),\n",
            "                    comment=None,\n",
            "                    newline=Newline(\n",
            "                        value=None,\n",
            "                    ),\n",
            "                ),\n",
            "            ),\n",
            "        ],\n",
            "        header=TrailingWhitespace(\n",
            "            whitespace=SimpleWhitespace(\n",
            "                value='',\n",
            "            ),\n",
            "            comment=None,\n",
            "            newline=Newline(\n",
            "                value=None,\n",
            "            ),\n",
            "        ),\n",
            "        indent=None,\n",
            "        footer=[],\n",
            "    ),\n",
            "    orelse=None,\n",
            "    leading_lines=[],\n",
            "    whitespace_after_while=SimpleWhitespace(\n",
            "        value=' ',\n",
            "    ),\n",
            "    whitespace_before_colon=SimpleWhitespace(\n",
            "        value='',\n",
            "    ),\n",
            ")] != [While(\n",
            "    test=Comparison(\n",
            "        left=Name(\n",
            "            value='x',\n",
            "            lpar=[],\n",
            "            rpar=[],\n",
            "        ),\n",
            "        comparisons=[\n",
            "            ComparisonTarget(\n",
            "                operator=LessThan(\n",
            "                    whitespace_before=SimpleWhitespace(\n",
            "                        value=' ',\n",
            "                    ),\n",
            "                    whitespace_after=SimpleWhitespace(\n",
            "                        value=' ',\n",
            "                    ),\n",
            "                ),\n",
            "                comparator=Subscript(\n",
            "                    value=Name(\n",
            "                        value='y',\n",
            "                        lpar=[],\n",
            "                        rpar=[],\n",
            "                    ),\n",
            "                    slice=[\n",
            "                        SubscriptElement(\n",
            "                            slice=Index(\n",
            "                                value=Integer(\n",
            "                                    value='10',\n",
            "                                    lpar=[],\n",
            "                                    rpar=[],\n",
            "                                ),\n",
            "                                star=None,\n",
            "                                whitespace_after_star=None,\n",
            "                            ),\n",
            "                            comma=MaybeSentinel.DEFAULT,\n",
            "                        ),\n",
            "                    ],\n",
            "                    lbracket=LeftSquareBracket(\n",
            "                        whitespace_after=SimpleWhitespace(\n",
            "                            value='',\n",
            "                        ),\n",
            "                    ),\n",
            "                    rbracket=RightSquareBracket(\n",
            "                        whitespace_before=SimpleWhitespace(\n",
            "                            value='',\n",
            "                        ),\n",
            "                    ),\n",
            "                    lpar=[],\n",
            "                    rpar=[],\n",
            "                    whitespace_after_value=SimpleWhitespace(\n",
            "                        value='',\n",
            "                    ),\n",
            "                ),\n",
            "            ),\n",
            "        ],\n",
            "        lpar=[],\n",
            "        rpar=[],\n",
            "    ),\n",
            "    body=IndentedBlock(\n",
            "        body=[\n",
            "            SimpleStatementLine(\n",
            "                body=[\n",
            "                    Expr(\n",
            "                        value=Call(\n",
            "                            func=Name(\n",
            "                                value='print',\n",
            "                                lpar=[],\n",
            "                                rpar=[],\n",
            "                            ),\n",
            "                            args=[\n",
            "                                Arg(\n",
            "                                    value=Name(\n",
            "                                        value='x',\n",
            "                                        lpar=[],\n",
            "                                        rpar=[],\n",
            "                                    ),\n",
            "                                    keyword=None,\n",
            "                                    equal=MaybeSentinel.DEFAULT,\n",
            "                                    comma=MaybeSentinel.DEFAULT,\n",
            "                                    star='',\n",
            "                                    whitespace_after_star=SimpleWhitespace(\n",
            "                                        value='',\n",
            "                                    ),\n",
            "                                    whitespace_after_arg=SimpleWhitespace(\n",
            "                                        value='',\n",
            "                                    ),\n",
            "                                ),\n",
            "                            ],\n",
            "                            lpar=[],\n",
            "                            rpar=[],\n",
            "                            whitespace_after_func=SimpleWhitespace(\n",
            "                                value='',\n",
            "                            ),\n",
            "                            whitespace_before_args=SimpleWhitespace(\n",
            "                                value='',\n",
            "                            ),\n",
            "                        ),\n",
            "                        semicolon=MaybeSentinel.DEFAULT,\n",
            "                    ),\n",
            "                ],\n",
            "                leading_lines=[],\n",
            "                trailing_whitespace=TrailingWhitespace(\n",
            "                    whitespace=SimpleWhitespace(\n",
            "                        value='',\n",
            "                    ),\n",
            "                    comment=None,\n",
            "                    newline=Newline(\n",
            "                        value=None,\n",
            "                    ),\n",
            "                ),\n",
            "            ),\n",
            "            SimpleStatementLine(\n",
            "                body=[\n",
            "                    Assign(\n",
            "                        targets=[\n",
            "                            AssignTarget(\n",
            "                                target=Name(\n",
            "                                    value='x',\n",
            "                                    lpar=[],\n",
            "                                    rpar=[],\n",
            "                                ),\n",
            "                                whitespace_before_equal=SimpleWhitespace(\n",
            "                                    value=' ',\n",
            "                                ),\n",
            "                                whitespace_after_equal=SimpleWhitespace(\n",
            "                                    value=' ',\n",
            "                                ),\n",
            "                            ),\n",
            "                        ],\n",
            "                        value=BinaryOperation(\n",
            "                            left=BinaryOperation(\n",
            "                                left=Subscript(\n",
            "                                    value=Name(\n",
            "                                        value='x',\n",
            "                                        lpar=[],\n",
            "                                        rpar=[],\n",
            "                                    ),\n",
            "                                    slice=[\n",
            "                                        SubscriptElement(\n",
            "                                            slice=Index(\n",
            "                                                value=Integer(\n",
            "                                                    value='2',\n",
            "                                                    lpar=[],\n",
            "                                                    rpar=[],\n",
            "                                                ),\n",
            "                                                star=None,\n",
            "                                                whitespace_after_star=None,\n",
            "                                            ),\n",
            "                                            comma=MaybeSentinel.DEFAULT,\n",
            "                                        ),\n",
            "                                    ],\n",
            "                                    lbracket=LeftSquareBracket(\n",
            "                                        whitespace_after=SimpleWhitespace(\n",
            "                                            value='',\n",
            "                                        ),\n",
            "                                    ),\n",
            "                                    rbracket=RightSquareBracket(\n",
            "                                        whitespace_before=SimpleWhitespace(\n",
            "                                            value='',\n",
            "                                        ),\n",
            "                                    ),\n",
            "                                    lpar=[],\n",
            "                                    rpar=[],\n",
            "                                    whitespace_after_value=SimpleWhitespace(\n",
            "                                        value='',\n",
            "                                    ),\n",
            "                                ),\n",
            "                                operator=Add(\n",
            "                                    whitespace_before=SimpleWhitespace(\n",
            "                                        value=' ',\n",
            "                                    ),\n",
            "                                    whitespace_after=SimpleWhitespace(\n",
            "                                        value=' ',\n",
            "                                    ),\n",
            "                                ),\n",
            "                                right=Integer(\n",
            "                                    value='1',\n",
            "                                    lpar=[],\n",
            "                                    rpar=[],\n",
            "                                ),\n",
            "                                lpar=[],\n",
            "                                rpar=[],\n",
            "                            ),\n",
            "                            operator=Add(\n",
            "                                whitespace_before=SimpleWhitespace(\n",
            "                                    value='',\n",
            "                                ),\n",
            "                                whitespace_after=SimpleWhitespace(\n",
            "                                    value='',\n",
            "                                ),\n",
            "                            ),\n",
            "                            right=Subscript(\n",
            "                                value=Name(\n",
            "                                    value='z',\n",
            "                                    lpar=[],\n",
            "                                    rpar=[],\n",
            "                                ),\n",
            "                                slice=[\n",
            "                                    SubscriptElement(\n",
            "                                        slice=Slice(\n",
            "                                            lower=Integer(\n",
            "                                                value='2',\n",
            "                                                lpar=[],\n",
            "                                                rpar=[],\n",
            "                                            ),\n",
            "                                            upper=Integer(\n",
            "                                                value='10',\n",
            "                                                lpar=[],\n",
            "                                                rpar=[],\n",
            "                                            ),\n",
            "                                            step=None,\n",
            "                                            first_colon=Colon(\n",
            "                                                whitespace_before=SimpleWhitespace(\n",
            "                                                    value='',\n",
            "                                                ),\n",
            "                                                whitespace_after=SimpleWhitespace(\n",
            "                                                    value='',\n",
            "                                                ),\n",
            "                                            ),\n",
            "                                            second_colon=MaybeSentinel.DEFAULT,\n",
            "                                        ),\n",
            "                                        comma=MaybeSentinel.DEFAULT,\n",
            "                                    ),\n",
            "                                ],\n",
            "                                lbracket=LeftSquareBracket(\n",
            "                                    whitespace_after=SimpleWhitespace(\n",
            "                                        value='',\n",
            "                                    ),\n",
            "                                ),\n",
            "                                rbracket=RightSquareBracket(\n",
            "                                    whitespace_before=SimpleWhitespace(\n",
            "                                        value='',\n",
            "                                    ),\n",
            "                                ),\n",
            "                                lpar=[],\n",
            "                                rpar=[],\n",
            "                                whitespace_after_value=SimpleWhitespace(\n",
            "                                    value='',\n",
            "                                ),\n",
            "                            ),\n",
            "                            lpar=[],\n",
            "                            rpar=[],\n",
            "                        ),\n",
            "                        semicolon=MaybeSentinel.DEFAULT,\n",
            "                    ),\n",
            "                ],\n",
            "                leading_lines=[],\n",
            "                trailing_whitespace=TrailingWhitespace(\n",
            "                    whitespace=SimpleWhitespace(\n",
            "                        value='',\n",
            "                    ),\n",
            "                    comment=None,\n",
            "                    newline=Newline(\n",
            "                        value=None,\n",
            "                    ),\n",
            "                ),\n",
            "            ),\n",
            "        ],\n",
            "        header=TrailingWhitespace(\n",
            "            whitespace=SimpleWhitespace(\n",
            "                value='',\n",
            "            ),\n",
            "            comment=None,\n",
            "            newline=Newline(\n",
            "                value=None,\n",
            "            ),\n",
            "        ),\n",
            "        indent=None,\n",
            "        footer=[],\n",
            "    ),\n",
            "    orelse=None,\n",
            "    leading_lines=[],\n",
            "    whitespace_after_while=SimpleWhitespace(\n",
            "        value=' ',\n",
            "    ),\n",
            "    whitespace_before_colon=SimpleWhitespace(\n",
            "        value='',\n",
            "    ),\n",
            ")]\n"
          ]
        },
        {
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "execution_count": 2,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "script = \"while x < y[10]:\\n\\tprint(x)\\n\\tx = x[2] + 1+y[2:10]\"\n",
        "script2 = \"while x < y[10]:\\n\\tprint(x)\\n\\tx = x[2] + 1+z[2:10]\"\n",
        "\n",
        "Module = cst.parse_module(script)\n",
        "Module2 = cst.parse_module(script2)\n",
        "deep_equals_with_print(Module, Module2)"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Useful LibCstDocs: \n",
        "\n",
        "https://libcst.readthedocs.io/en/latest/metadata.html#position-metadata\n",
        "\n",
        "https://libcst.readthedocs.io/en/latest/_modules/libcst/metadata/position_provider.html#PositionProvider\n",
        "\n",
        "https://libcst.readthedocs.io/en/latest/_modules/libcst/metadata/position_provider.html#WhitespaceInclusivePositionProvidingCodegenState\n",
        "\n",
        "\n",
        "https://libcst.readthedocs.io/en/latest/parser.html"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## PositionContextUpdater and is_modified\n",
        "Because we want to apply potentially random changes to the code we need to introduce some simple helper methods, contained in the is_modified function that use the meta-data saved from transformers after modifyng a node to prevent any other transformer from applying further modifications to the either Node, its parent or its childrens. \n",
        "\n",
        "Since each node modification might introduce or remove code we also use the PositionContextUpdater to maintain the context scratch consistent after each mutation."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {},
      "outputs": [],
      "source": [
        "from openbugger.context import is_modified, save_modified, is_parent_CodeRange, is_child_CodeRange, is_equal_Coderange, PositionContextUpdater"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Bugger and InverseTransformer"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {},
      "outputs": [],
      "source": [
        "from openbugger.bugger import Bugger, TestTransformer, bugger_example, InverseTransformer"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Example Debugging Output Using the Test Tranformer"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "original_code\n",
            "while x < y[10]:\n",
            "\tprint(x)\n",
            "\tx = x[2] + 1+y[2:10]\n",
            "tainted_code\n",
            "while x < y[10]:\n",
            "\tprint(x)\n",
            "\tx = x[2] + 1+y[2:10]\n",
            "The result of deep_equals between the concrete syntax tree of the original and the bugged code is True\n",
            "Checking for bugs...\n",
            "The following Node has a bug of type TestTransformer-b87c starting at line 1, column 12 and ending at line 1, column 14.\n",
            "The bug can be fixed by substituting the bugged code-string <10> with the following code-string <10>\n",
            "The following Node has a bug of type TestTransformer-b87c starting at line 3, column 7 and ending at line 3, column 8.\n",
            "The bug can be fixed by substituting the bugged code-string <2> with the following code-string <2>\n",
            "The following Node has a bug of type TestTransformer-b87c starting at line 3, column 16 and ending at line 3, column 20.\n",
            "The bug can be fixed by substituting the bugged code-string <2:10> with the following code-string <2:10>\n",
            "Debugging...\n",
            "clean_code\n",
            "while x < y[10]:\n",
            "\tprint(x)\n",
            "\tx = x[2] + 1+y[2:10]\n",
            "Checking if the debugged code is equal to the original code..\n",
            "The result of deep_equals between the concrete syntax tree of the original and debugged code is True\n"
          ]
        }
      ],
      "source": [
        "transformers = [TestTransformer]\n",
        "# Get the script as a string it should have  while loop and take multiple lines\n",
        "script = \"while x < y[10]:\\n\\tprint(x)\\n\\tx = x[2] + 1+y[2:10]\"\n",
        "bugger_example(transformers,script)\n"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "# Example Bugs \n",
        "\n",
        "In this section of the notebook we develop the 5/12 example bugs using LibCST ContextAwareTransformer that use the is_modified method to check if the node was already targeted by a mutation and then apply the mutation and save the mutation to the scratchpad using save_modified method.\n",
        "\n",
        "The bugs are:\n",
        "\n",
        "1. incorrect_comparison_operator - Done\n",
        "2. comparison_swap - Done\n",
        "3. forgetting_to_update_variable - Done\n",
        "4. infinite_loop - Done\n",
        "5. off_by_k_index - Done\n",
        "6. incorrect_return_value\n",
        "7. incorrect_boolean_operator\n",
        "8. using_wrong_type_of_loop\n",
        "9. using_loop_variable_outside_loop\n",
        "10. using_variable_before_assignment\n",
        "11. using_wrong_variable_scope\n",
        "12. incorrect_use_of_exception_handling\n",
        "13. incorrect_function_call\n",
        "\n",
        "The current approach only allows for the scratchpad context to be passed as initialization to the transformers, therefore we use generator functions for the bugs that could take multiple inputs like which operator to swap. These transformers apply the bug to ALL the target instances they find, we will derive some wrapper in the later part of the notebook to control the number of bugs or target a specific code-range."
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## LogicalBugs"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {},
      "outputs": [],
      "source": [
        "from openbugger.bugs.logical import gen_ComparisonTargetTransfomer, ComparisonSwapTransformer"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Incorrect Comparison Operator\n",
        "This bug takes as input two libcst comparison operators and swaps every instance of the first for the second"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "original_code\n",
            "x == 1 + 2 == 3 + 2 != 3 + 4 > 3\n",
            "tainted_code\n",
            "x != 1 + 2 != 3 + 2 != 3 + 4 > 3\n",
            "The result of deep_equals between the concrete syntax tree of the original and the bugged code is False\n",
            "Checking for bugs...\n",
            "The following Node has a bug of type ComparisonTargetTransformer-a2c2 starting at line 1, column 1 and ending at line 1, column 10.\n",
            "The bug can be fixed by substituting the bugged code-string < != 1 + 2> with the following code-string < == 1 + 2>\n",
            "The following Node has a bug of type ComparisonTargetTransformer-a2c2 starting at line 1, column 10 and ending at line 1, column 19.\n",
            "The bug can be fixed by substituting the bugged code-string < != 3 + 2> with the following code-string < == 3 + 2>\n",
            "Debugging...\n",
            "clean_code\n",
            "x == 1 + 2 == 3 + 2 != 3 + 4 > 3\n",
            "Checking if the debugged code is equal to the original code..\n",
            "The result of deep_equals between the concrete syntax tree of the original and debugged code is True\n"
          ]
        }
      ],
      "source": [
        "transformers = [gen_ComparisonTargetTransfomer('==','!=')]\n",
        "# Get the script as a string\n",
        "script = \"x == 1 + 2 == 3 + 2 != 3 + 4 > 3\"\n",
        "\n",
        "bugger_example(transformers,script)"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Comparison Swap"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "original_code\n",
            "x == 1 + 2 == 3 + 2 != 3 + 4 > 3 \n",
            "tainted_code\n",
            "1 + 2 == x == 3 + 2 != 3 + 4 > 3 \n",
            "The result of deep_equals between the concrete syntax tree of the original and the bugged code is False\n",
            "Checking for bugs...\n",
            "The following Node has a bug of type ComparisonSwapTransformer-26b2 starting at line 1, column 0 and ending at line 1, column 32.\n",
            "The bug can be fixed by substituting the bugged code-string <1 + 2 == x == 3 + 2 != 3 + 4 > 3> with the following code-string <x == 1 + 2 == 3 + 2 != 3 + 4 > 3>\n",
            "Debugging...\n",
            "clean_code\n",
            "x == 1 + 2 == 3 + 2 != 3 + 4 > 3 \n",
            "Checking if the debugged code is equal to the original code..\n",
            "The result of deep_equals between the concrete syntax tree of the original and debugged code is True\n"
          ]
        }
      ],
      "source": [
        "transformers = [ComparisonSwapTransformer]\n",
        "# Get the script as a string\n",
        "script = \"x == 1 + 2 == 3 + 2 != 3 + 4 > 3 \"\n",
        "bugger_example(transformers,script)"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## ControlFLow Bugs"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {},
      "outputs": [],
      "source": [
        "from openbugger.bugs.controlflow import ForgettingToUpdateVariableTransformer, InfiniteWhileTransformer,gen_OffByKIndexTransformer"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### ForgettingToUpdateVariable"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "original_code\n",
            "while x == 1 + 2 == 3 + 2 != 3 + 4 > 3 : \n",
            "  y = 1 + 2\n",
            "tainted_code\n",
            "while x == 1 + 2 == 3 + 2 != 3 + 4 > 3 : \n",
            "  y = y\n",
            "The result of deep_equals between the concrete syntax tree of the original and the bugged code is False\n",
            "Checking for bugs...\n",
            "The following Node has a bug of type ForgettingToUpdateVariableTransformer-9c62 starting at line 2, column 2 and ending at line 2, column 7.\n",
            "The bug can be fixed by substituting the bugged code-string <y = y> with the following code-string <y = 1 + 2>\n",
            "Debugging...\n",
            "clean_code\n",
            "while x == 1 + 2 == 3 + 2 != 3 + 4 > 3 : \n",
            "  y = 1 + 2\n",
            "Checking if the debugged code is equal to the original code..\n",
            "The result of deep_equals between the concrete syntax tree of the original and debugged code is True\n"
          ]
        }
      ],
      "source": [
        "transformers = [ForgettingToUpdateVariableTransformer]\n",
        "# Get the script as a string\n",
        "script = \"while x == 1 + 2 == 3 + 2 != 3 + 4 > 3 : \\n  y = 1 + 2\"\n",
        "bugger_example(transformers,script)"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Infinite While Loop"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "original_code\n",
            "while x == 1 + 2 == 3 + 2 != 3 + 4 > 3: \n",
            "  y = 1 + 2\n",
            "tainted_code\n",
            "while True: \n",
            "  y = 1 + 2\n",
            "The result of deep_equals between the concrete syntax tree of the original and the bugged code is False\n",
            "Checking for bugs...\n",
            "The following Node has a bug of type InfiniteWhileTransformer-e885 starting at line 1, column 0 and ending at line 2, column 11.\n",
            "The bug can be fixed by substituting the bugged code-string <while True: \n",
            "  y = 1 + 2\n",
            "> with the following code-string <while x == 1 + 2 == 3 + 2 != 3 + 4 > 3: \n",
            "  y = 1 + 2\n",
            ">\n",
            "Debugging...\n",
            "clean_code\n",
            "while x == 1 + 2 == 3 + 2 != 3 + 4 > 3: \n",
            "  y = 1 + 2\n",
            "Checking if the debugged code is equal to the original code..\n",
            "The result of deep_equals between the concrete syntax tree of the original and debugged code is True\n"
          ]
        }
      ],
      "source": [
        "transformers = [InfiniteWhileTransformer]\n",
        "# Get the script as a string\n",
        "script = \"while x == 1 + 2 == 3 + 2 != 3 + 4 > 3: \\n  y = 1 + 2\"\n",
        "bugger_example(transformers,script)"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### OffByKIndex "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "original_code\n",
            "while x == 1 + 2 == 3 + 2 != 3 + 4 > 3: \n",
            "  y = 1 + 2\n",
            "x[1:2]\n",
            "x[1]\n",
            "tainted_code\n",
            "while x == 1 + 2 == 3 + 2 != 3 + 4 > 3: \n",
            "  y = 1 + 2\n",
            "x[2:3]\n",
            "x[2]\n",
            "The result of deep_equals between the concrete syntax tree of the original and the bugged code is False\n",
            "Checking for bugs...\n",
            "The following Node has a bug of type OffByKIndexTransformer-d1a2 starting at line 3, column 2 and ending at line 3, column 5.\n",
            "The bug can be fixed by substituting the bugged code-string <2:3> with the following code-string <1:2>\n",
            "The following Node has a bug of type OffByKIndexTransformer-d1a2 starting at line 4, column 2 and ending at line 4, column 3.\n",
            "The bug can be fixed by substituting the bugged code-string <2> with the following code-string <1>\n",
            "Debugging...\n",
            "clean_code\n",
            "while x == 1 + 2 == 3 + 2 != 3 + 4 > 3: \n",
            "  y = 1 + 2\n",
            "x[1:2]\n",
            "x[1]\n",
            "Checking if the debugged code is equal to the original code..\n",
            "The result of deep_equals between the concrete syntax tree of the original and debugged code is True\n"
          ]
        }
      ],
      "source": [
        "transformers = [gen_OffByKIndexTransformer(1)]\n",
        "# Get the script as a string\n",
        "script = \"while x == 1 + 2 == 3 + 2 != 3 + 4 > 3: \\n  y = 1 + 2\\nx[1:2]\\nx[1]\"\n",
        "bugger_example(transformers,script)"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Incorrect Exception Handling\n",
        "Catching the wrong exceptions, or incorrect use of the `try/except/finally` block."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "metadata": {},
      "outputs": [],
      "source": [
        "from openbugger.bugs.controlflow import IncorrectExceptionHandlerTransformer"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 14,
      "metadata": {},
      "outputs": [],
      "source": [
        "script= \"\"\"try:\n",
        "    x = 1 / 0\n",
        "except ZeroDivisionError:\n",
        "    print('Zero division error!')\n",
        "\"\"\"\n",
        "expected_output= \"\"\"try:\n",
        "    x = 1 / 0\n",
        "except:\n",
        "    print('Zero division error!')\n",
        "\"\"\""
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 15,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "original_code\n",
            "try:\n",
            "    x = 1 / 0\n",
            "except ZeroDivisionError:\n",
            "    print('Zero division error!')\n",
            "\n",
            "tainted_code\n",
            "try:\n",
            "    x = 1 / 0\n",
            "except :\n",
            "    print('Zero division error!')\n",
            "\n",
            "The result of deep_equals between the concrete syntax tree of the original and the bugged code is False\n",
            "Checking for bugs...\n",
            "The following Node has a bug of type IncorrectExceptionHandlerTransformer-87fb starting at line 3, column 0 and ending at line 4, column 33.\n",
            "The bug can be fixed by substituting the bugged code-string <except :\n",
            "    print('Zero division error!')\n",
            "> with the following code-string <except ZeroDivisionError:\n",
            "    print('Zero division error!')\n",
            ">\n",
            "Debugging...\n",
            "clean_code\n",
            "try:\n",
            "    x = 1 / 0\n",
            "except ZeroDivisionError:\n",
            "    print('Zero division error!')\n",
            "\n",
            "Checking if the debugged code is equal to the original code..\n",
            "The result of deep_equals between the concrete syntax tree of the original and debugged code is True\n"
          ]
        }
      ],
      "source": [
        "transformers = [IncorrectExceptionHandlerTransformer]\n",
        "bugger_example(transformers,script)"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Missing Argument Transformer\n",
        "Calling functions in the wrong sequence."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 16,
      "metadata": {},
      "outputs": [],
      "source": [
        "from openbugger.bugs.controlflow import MissingArgumentTransformer"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 17,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "original_code\n",
            "print(str(123))\n",
            "tainted_code\n",
            "print(str())\n",
            "The result of deep_equals between the concrete syntax tree of the original and the bugged code is False\n",
            "Checking for bugs...\n",
            "The following Node has a bug of type MissingArgumentTransformer-14d8 starting at line 1, column 6 and ending at line 1, column 11.\n",
            "The bug can be fixed by substituting the bugged code-string <str()> with the following code-string <str(123)>\n",
            "Debugging...\n",
            "clean_code\n",
            "print(str(123))\n",
            "Checking if the debugged code is equal to the original code..\n",
            "The result of deep_equals between the concrete syntax tree of the original and debugged code is True\n"
          ]
        }
      ],
      "source": [
        "script= \"\"\"print(str(123))\"\"\"\n",
        "expected_output = \"\"\"print(str())\"\"\"\n",
        "transformers = [MissingArgumentTransformer]\n",
        "bugger_example(transformers,script)\n"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### ReturningEarly\n",
        "Returning from a function before all the necessary computations have been made."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 18,
      "metadata": {},
      "outputs": [],
      "source": [
        "from openbugger.bugs.controlflow import ReturningEarlyTransformer\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 19,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "original_code\n",
            "def add(x, y):\n",
            "    return x + y\n",
            "    print('This will not be printed.')\n",
            "\n",
            "tainted_code\n",
            "def add(x, y):\n",
            "    return\n",
            "    print('This will not be printed.')\n",
            "\n",
            "The result of deep_equals between the concrete syntax tree of the original and the bugged code is False\n",
            "Checking for bugs...\n",
            "The following Node has a bug of type ReturningEarlyTransformer-9b55 starting at line 2, column 4 and ending at line 2, column 10.\n",
            "The bug can be fixed by substituting the bugged code-string <return> with the following code-string <return x + y>\n",
            "Debugging...\n",
            "clean_code\n",
            "def add(x, y):\n",
            "    return x + y\n",
            "    print('This will not be printed.')\n",
            "\n",
            "Checking if the debugged code is equal to the original code..\n",
            "The result of deep_equals between the concrete syntax tree of the original and debugged code is True\n"
          ]
        }
      ],
      "source": [
        "script= \"\"\"def add(x, y):\n",
        "    return x + y\n",
        "    print('This will not be printed.')\n",
        "\"\"\"\n",
        "expected_output = \"\"\"def add(x, y):\n",
        "    return\n",
        "    print('This will not be printed.')\n",
        "\"\"\"\n",
        "transformers = [ReturningEarlyTransformer]\n",
        "bugger_example(transformers,script)"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Data Related Bugs"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Incorrect variable initialization\n",
        "Variables are initialized with incorrect values."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 20,
      "metadata": {},
      "outputs": [],
      "source": [
        "from openbugger.bugs.data import IncorrectVariableInitializationTransformer"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 21,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "original_code\n",
            "var1 = 5\n",
            "var2 = \"hello\"\n",
            "var3 = [1, 2, 3]\n",
            "var4 = {\"key\": \"value\"}\n",
            "var5 = True\n",
            "var6 = None\n",
            "\n",
            "tainted_code\n",
            "var1 = 5\n",
            "var2 = \"bar\"\n",
            "var3 = [3, 2, 3]\n",
            "var4 = {\"key\": \"baz\"}\n",
            "var5 = False\n",
            "var6 = 0\n",
            "\n",
            "The result of deep_equals between the concrete syntax tree of the original and the bugged code is False\n",
            "Checking for bugs...\n",
            "The following Node has a bug of type IncorrectVariableInitializationTransformer-a070 starting at line 1, column 0 and ending at line 1, column 8.\n",
            "The bug can be fixed by substituting the bugged code-string <var1 = 5> with the following code-string <var1 = 5>\n",
            "The following Node has a bug of type IncorrectVariableInitializationTransformer-a070 starting at line 2, column 0 and ending at line 2, column 12.\n",
            "The bug can be fixed by substituting the bugged code-string <var2 = \"bar\"> with the following code-string <var2 = \"hello\">\n",
            "The following Node has a bug of type IncorrectVariableInitializationTransformer-a070 starting at line 3, column 7 and ending at line 3, column 16.\n",
            "The bug can be fixed by substituting the bugged code-string <[3, 2, 3]> with the following code-string <[1, 2, 3]>\n",
            "The following Node has a bug of type IncorrectVariableInitializationTransformer-a070 starting at line 4, column 7 and ending at line 4, column 21.\n",
            "The bug can be fixed by substituting the bugged code-string <{\"key\": \"baz\"}> with the following code-string <{\"key\": \"value\"}>\n",
            "The following Node has a bug of type IncorrectVariableInitializationTransformer-a070 starting at line 5, column 0 and ending at line 5, column 12.\n",
            "The bug can be fixed by substituting the bugged code-string <var5 = False> with the following code-string <var5 = True>\n",
            "The following Node has a bug of type IncorrectVariableInitializationTransformer-a070 starting at line 6, column 0 and ending at line 6, column 8.\n",
            "The bug can be fixed by substituting the bugged code-string <var6 = 0> with the following code-string <var6 = None>\n",
            "Debugging...\n",
            "clean_code\n",
            "var1 = 5\n",
            "var2 = \"hello\"\n",
            "var3 = [1, 2, 3]\n",
            "var4 = {\"key\": \"value\"}\n",
            "var5 = True\n",
            "var6 = None\n",
            "\n",
            "Checking if the debugged code is equal to the original code..\n",
            "The result of deep_equals between the concrete syntax tree of the original and debugged code is True\n"
          ]
        }
      ],
      "source": [
        "script = \"\"\"var1 = 5\n",
        "var2 = \"hello\"\n",
        "var3 = [1, 2, 3]\n",
        "var4 = {\"key\": \"value\"}\n",
        "var5 = True\n",
        "var6 = None\n",
        "\"\"\"\n",
        "possible_output = \"\"\"var1 = 2\n",
        "var2 = \"bar\"\n",
        "var3 = ['a', 'b', 'c']\n",
        "var4 = {}\n",
        "var5 = False\n",
        "var6 = None\n",
        "\"\"\"\n",
        "transformers = [IncorrectVariableInitializationTransformer]\n",
        "bugger_example(transformers,script)"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Variable Name Typo\n",
        "Mistyping the names of variables, causing them to be treated as new, uninitialized variables."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 22,
      "metadata": {},
      "outputs": [],
      "source": [
        "from openbugger.bugs.data import VariableNameTypoTransformer"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 23,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "original_code\n",
            "var1 = 5\n",
            "var2 = \"hello\"\n",
            "var1 = var2\n",
            "\n",
            "tainted_code\n",
            "var1var1 = 5\n",
            "var2var2 = \"hello\"\n",
            "var1var1 = var2\n",
            "\n",
            "The result of deep_equals between the concrete syntax tree of the original and the bugged code is False\n",
            "Checking for bugs...\n",
            "The following Node has a bug of type VariableNameTypoTransformer-45bb starting at line 1, column 0 and ending at line 1, column 12.\n",
            "The bug can be fixed by substituting the bugged code-string <var1var1 = 5> with the following code-string <var1 = 5>\n",
            "The following Node has a bug of type VariableNameTypoTransformer-45bb starting at line 2, column 0 and ending at line 2, column 18.\n",
            "The bug can be fixed by substituting the bugged code-string <var2var2 = \"hello\"> with the following code-string <var2 = \"hello\">\n",
            "The following Node has a bug of type VariableNameTypoTransformer-45bb starting at line 3, column 0 and ending at line 3, column 15.\n",
            "The bug can be fixed by substituting the bugged code-string <var1var1 = var2> with the following code-string <var1 = var2>\n",
            "Debugging...\n",
            "clean_code\n",
            "var1 = 5\n",
            "var2 = \"hello\"\n",
            "var1 = var2\n",
            "\n",
            "Checking if the debugged code is equal to the original code..\n",
            "The result of deep_equals between the concrete syntax tree of the original and debugged code is True\n"
          ]
        }
      ],
      "source": [
        "script = \"\"\"var1 = 5\n",
        "var2 = \"hello\"\n",
        "var1 = var2\n",
        "\"\"\"\n",
        "possible_output = \"\"\"var1 = 5\n",
        "var2 = \"hello\"\n",
        "var1_var2 = var2\n",
        "\"\"\"\n",
        "transformers = [VariableNameTypoTransformer]\n",
        "bugger_example(transformers,script)"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Mutable Default Arguments\n",
        "Using mutable types (like lists or dictionaries) as default function arguments."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 24,
      "metadata": {},
      "outputs": [],
      "source": [
        "from openbugger.bugs.data import MutableDefaultArgumentTransformer"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 25,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "original_code\n",
            "def func1(arg1, arg2, arg3):\n",
            "    return arg1 + arg2\n",
            "tainted_code\n",
            "def func1(arg1, arg2, arg3 = []):\n",
            "    arg3.append(1)\n",
            "    return arg1 + arg2\n",
            "The result of deep_equals between the concrete syntax tree of the original and the bugged code is False\n",
            "Checking for bugs...\n",
            "The following Node has a bug of type MutableDefaultArgumentTransformer-1687 starting at line 1, column 0 and ending at line 3, column 22.\n",
            "The bug can be fixed by substituting the bugged code-string <def func1(arg1, arg2, arg3 = []):\n",
            "    arg3.append(1)\n",
            "    return arg1 + arg2\n",
            "> with the following code-string <def func1(arg1, arg2, arg3):\n",
            "    return arg1 + arg2\n",
            ">\n",
            "Debugging...\n",
            "clean_code\n",
            "def func1(arg1, arg2, arg3):\n",
            "    return arg1 + arg2\n",
            "Checking if the debugged code is equal to the original code..\n",
            "The result of deep_equals between the concrete syntax tree of the original and debugged code is True\n"
          ]
        }
      ],
      "source": [
        "script = \"\"\"def func1(arg1, arg2, arg3):\n",
        "    return arg1 + arg2\"\"\"\n",
        "\n",
        "transformers = [MutableDefaultArgumentTransformer]\n",
        "bugger_example(transformers,script)"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Using Variable before Assignment"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 26,
      "metadata": {},
      "outputs": [],
      "source": [
        "from openbugger.bugs.data import UseBeforeDefinitionTransformer"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 27,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "original_code\n",
            "def add_two_numbers(a, b):\n",
            "    return a + b\n",
            "tainted_code\n",
            "def add_two_numbers(a, b):\n",
            "    ba = b + 1\n",
            "    return a + b\n",
            "The result of deep_equals between the concrete syntax tree of the original and the bugged code is False\n",
            "Checking for bugs...\n",
            "The following Node has a bug of type UseBeforeDefinitionTransformer-c4e1 starting at line 1, column 0 and ending at line 3, column 16.\n",
            "The bug can be fixed by substituting the bugged code-string <def add_two_numbers(a, b):\n",
            "    ba = b + 1\n",
            "    return a + b\n",
            "> with the following code-string <def add_two_numbers(a, b):\n",
            "    return a + b\n",
            ">\n",
            "Debugging...\n",
            "clean_code\n",
            "def add_two_numbers(a, b):\n",
            "    return a + b\n",
            "Checking if the debugged code is equal to the original code..\n",
            "The result of deep_equals between the concrete syntax tree of the original and debugged code is True\n"
          ]
        }
      ],
      "source": [
        "script = \"\"\"def add_two_numbers(a, b):\n",
        "    return a + b\"\"\"\n",
        "expected_output = \"\"\"def add_two_numbers(a, b):\n",
        "    return a + temp  # 'temp' is used before it's defined\n",
        "    temp = b\"\"\"\n",
        "transformers = [UseBeforeDefinitionTransformer]\n",
        "bugger_example(transformers,script)"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Type-related Bugs"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "# Incorrect type used: \n",
        "Using an integer when a string was expected, or vice versa."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 28,
      "metadata": {},
      "outputs": [],
      "source": [
        "from openbugger.bugs.type import IncorrectTypeTransformer"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 29,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "original_code\n",
            "def function():\n",
            "    return 10\n",
            "tainted_code\n",
            "def function():\n",
            "    return \"10\"\n",
            "The result of deep_equals between the concrete syntax tree of the original and the bugged code is False\n",
            "Checking for bugs...\n",
            "The following Node has a bug of type IncorrectTypeTransformer-694c starting at line 2, column 11 and ending at line 2, column 15.\n",
            "The bug can be fixed by substituting the bugged code-string <\"10\"> with the following code-string <10>\n",
            "Debugging...\n",
            "clean_code\n",
            "def function():\n",
            "    return 10\n",
            "Checking if the debugged code is equal to the original code..\n",
            "The result of deep_equals between the concrete syntax tree of the original and debugged code is True\n"
          ]
        }
      ],
      "source": [
        "script = \"\"\"def function():\n",
        "    return 10\"\"\"\n",
        "# script  = \"\"\"def function():\n",
        "#     return \"10\" \"\"\"\n",
        "# # script = \"\"\"def function():\n",
        "# #     return 10.5\"\"\"\n",
        "transformers = [IncorrectTypeTransformer]\n",
        "bugger_example(transformers,script)\n"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Calling non existing Methods"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 30,
      "metadata": {},
      "outputs": [],
      "source": [
        "\n",
        "from openbugger.bugs.type import NonExistingMethodTransformer"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 31,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "original_code\n",
            "my_list = [1, 2, 3]\n",
            "my_list.append(4)\n",
            "\n",
            "tainted_code\n",
            "my_list = [1, 2, 3]\n",
            "my_list.update(4)\n",
            "\n",
            "The result of deep_equals between the concrete syntax tree of the original and the bugged code is False\n",
            "Checking for bugs...\n",
            "The following Node has a bug of type NonExistingMethodTransformer-7ff6 starting at line 2, column 0 and ending at line 2, column 17.\n",
            "The bug can be fixed by substituting the bugged code-string <my_list.update(4)> with the following code-string <my_list.append(4)>\n",
            "Debugging...\n",
            "clean_code\n",
            "my_list = [1, 2, 3]\n",
            "my_list.append(4)\n",
            "\n",
            "Checking if the debugged code is equal to the original code..\n",
            "The result of deep_equals between the concrete syntax tree of the original and debugged code is True\n"
          ]
        }
      ],
      "source": [
        "script = \"\"\"my_list = [1, 2, 3]\n",
        "my_list.append(4)\n",
        "\"\"\"\n",
        "transformers = [NonExistingMethodTransformer]\n",
        "bugger_example(transformers,script)"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "# Using wrong type of loop\n",
        " Using a `for` loop when a `while` loop would be more appropriate, and vice versa."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 32,
      "metadata": {},
      "outputs": [],
      "source": [
        "\n",
        "\n",
        "from openbugger.bugs.type import SwapForTransformer"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 33,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "original_code\n",
            "for i in range(10):\n",
            "    print(i)\n",
            "tainted_code\n",
            "while next(range(10)):\n",
            "    print(i)\n",
            "The result of deep_equals between the concrete syntax tree of the original and the bugged code is False\n",
            "Checking for bugs...\n",
            "The following Node has a bug of type SwapForTransformer-327c starting at line 1, column 0 and ending at line 2, column 12.\n",
            "The bug can be fixed by substituting the bugged code-string <while next(range(10)):\n",
            "    print(i)\n",
            "> with the following code-string <for i in range(10):\n",
            "    print(i)\n",
            ">\n",
            "Debugging...\n",
            "clean_code\n",
            "for i in range(10):\n",
            "    print(i)\n",
            "Checking if the debugged code is equal to the original code..\n",
            "The result of deep_equals between the concrete syntax tree of the original and debugged code is True\n"
          ]
        }
      ],
      "source": [
        "script = \"\"\"for i in range(10):\n",
        "    print(i)\"\"\"\n",
        "\n",
        "transformers = [SwapForTransformer]\n",
        "bugger_example(transformers,script)"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Numpy Bugs"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### numpy creation bug\n",
        "Initalizes a numpy array with empty instead of array"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 34,
      "metadata": {},
      "outputs": [],
      "source": [
        "from openbugger.bugs.numpy import NumpyArrayCreationTransformer"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 35,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "original_code\n",
            "def create_array():\n",
            "    arr = numpy.array([1, 2, 3])\n",
            "    return arr\n",
            "tainted_code\n",
            "def create_array():\n",
            "    arr = numpy.empty([1, 2, 3])\n",
            "    return arr\n",
            "The result of deep_equals between the concrete syntax tree of the original and the bugged code is False\n",
            "Checking for bugs...\n",
            "The following Node has a bug of type NumpyArrayCreationTransformer-4d97 starting at line 2, column 10 and ending at line 2, column 32.\n",
            "The bug can be fixed by substituting the bugged code-string <numpy.empty([1, 2, 3])> with the following code-string <numpy.array([1, 2, 3])>\n",
            "Debugging...\n",
            "clean_code\n",
            "def create_array():\n",
            "    arr = numpy.array([1, 2, 3])\n",
            "    return arr\n",
            "Checking if the debugged code is equal to the original code..\n",
            "The result of deep_equals between the concrete syntax tree of the original and debugged code is True\n"
          ]
        }
      ],
      "source": [
        "script = \"\"\"def create_array():\n",
        "    arr = numpy.array([1, 2, 3])\n",
        "    return arr\"\"\"\n",
        "transformers = [NumpyArrayCreationTransformer]\n",
        "bugger_example(transformers,script)"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Numpy Sort to argsort "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 36,
      "metadata": {},
      "outputs": [],
      "source": [
        "from openbugger.bugs.numpy import NumpyMethodMisuseTransformer"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 37,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "original_code\n",
            "\n",
            "import numpy as np\n",
            "\n",
            "def sort_array():\n",
            "    arr = np.array([3, 1, 2])\n",
            "    sorted_arr = np.sort(arr)\n",
            "    return sorted_arr\n",
            "\n",
            "tainted_code\n",
            "\n",
            "import numpy as np\n",
            "\n",
            "def sort_array():\n",
            "    arr = np.array([3, 1, 2])\n",
            "    sorted_arr = np.argsort(arr)\n",
            "    return sorted_arr\n",
            "\n",
            "The result of deep_equals between the concrete syntax tree of the original and the bugged code is False\n",
            "Checking for bugs...\n",
            "The following Node has a bug of type NumpyMethodMisuseTransformer-f5f3 starting at line 6, column 17 and ending at line 6, column 32.\n",
            "The bug can be fixed by substituting the bugged code-string <np.argsort(arr)> with the following code-string <np.sort(arr)>\n",
            "Debugging...\n",
            "clean_code\n",
            "\n",
            "import numpy as np\n",
            "\n",
            "def sort_array():\n",
            "    arr = np.array([3, 1, 2])\n",
            "    sorted_arr = np.sort(arr)\n",
            "    return sorted_arr\n",
            "\n",
            "Checking if the debugged code is equal to the original code..\n",
            "The result of deep_equals between the concrete syntax tree of the original and debugged code is True\n"
          ]
        }
      ],
      "source": [
        "script = \"\"\"\n",
        "import numpy as np\n",
        "\n",
        "def sort_array():\n",
        "    arr = np.array([3, 1, 2])\n",
        "    sorted_arr = np.sort(arr)\n",
        "    return sorted_arr\n",
        "\"\"\"\n",
        "transformers = [NumpyMethodMisuseTransformer]\n",
        "bugger_example(transformers,script)"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### WrongReshape"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 38,
      "metadata": {},
      "outputs": [],
      "source": [
        "\n",
        "from openbugger.bugs.numpy import NumpyReshapeMisuseTransformer\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 39,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "original_code\n",
            "def reshape_array():\n",
            "    arr = np.array([[1, 2, 3], [4, 5, 6]])\n",
            "    reshaped_arr = arr.reshape([2, 3])\n",
            "    return reshaped_arr\n",
            "tainted_code\n",
            "def reshape_array():\n",
            "    arr = np.array([[1, 2, 3], [4, 5, 6]])\n",
            "    reshaped_arr = arr.reshape([3, 3])\n",
            "    return reshaped_arr\n",
            "The result of deep_equals between the concrete syntax tree of the original and the bugged code is False\n",
            "Checking for bugs...\n",
            "The following Node has a bug of type NumpyReshapeMisuseTransformer-5b78 starting at line 3, column 19 and ending at line 3, column 38.\n",
            "The bug can be fixed by substituting the bugged code-string <arr.reshape([3, 3])> with the following code-string <arr.reshape([2, 3])>\n",
            "Debugging...\n",
            "clean_code\n",
            "def reshape_array():\n",
            "    arr = np.array([[1, 2, 3], [4, 5, 6]])\n",
            "    reshaped_arr = arr.reshape([2, 3])\n",
            "    return reshaped_arr\n",
            "Checking if the debugged code is equal to the original code..\n",
            "The result of deep_equals between the concrete syntax tree of the original and debugged code is True\n"
          ]
        }
      ],
      "source": [
        "script = \"\"\"def reshape_array():\n",
        "    arr = np.array([[1, 2, 3], [4, 5, 6]])\n",
        "    reshaped_arr = arr.reshape([2, 3])\n",
        "    return reshaped_arr\"\"\"\n",
        "transformers = [NumpyReshapeMisuseTransformer]\n",
        "bugger_example(transformers,script)"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### numpy arange"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 40,
      "metadata": {},
      "outputs": [],
      "source": [
        "from openbugger.bugs.numpy import NumpyArangeMisuseTransformer\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 41,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "original_code\n",
            "data = np.arange(10)\n",
            "tainted_code\n",
            "data = np.arange(10.4)\n",
            "The result of deep_equals between the concrete syntax tree of the original and the bugged code is False\n",
            "Checking for bugs...\n",
            "The following Node has a bug of type NumpyArangeMisuseTransformer-618d starting at line 1, column 7 and ending at line 1, column 22.\n",
            "The bug can be fixed by substituting the bugged code-string <np.arange(10.4)> with the following code-string <np.arange(10)>\n",
            "Debugging...\n",
            "clean_code\n",
            "data = np.arange(10)\n",
            "Checking if the debugged code is equal to the original code..\n",
            "The result of deep_equals between the concrete syntax tree of the original and debugged code is True\n"
          ]
        }
      ],
      "source": [
        "script= \"\"\"data = np.arange(10)\"\"\"\n",
        "transformers = [NumpyArangeMisuseTransformer]\n",
        "bugger_example(transformers,script)"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Numpy axis misuses"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 42,
      "metadata": {},
      "outputs": [],
      "source": [
        "from openbugger.bugs.numpy import NumpyAxisMisuseTransformer\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 43,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "original_code\n",
            "data = numpy.array([[1, 2, 3], [4, 5, 6]])\n",
            "sum_along_axis = numpy.sum(data, axis=16)\n",
            "tainted_code\n",
            "data = numpy.array([[1, 2, 3], [4, 5, 6]])\n",
            "sum_along_axis = numpy.sum(data, axis = 1)\n",
            "The result of deep_equals between the concrete syntax tree of the original and the bugged code is False\n",
            "Checking for bugs...\n",
            "The following Node has a bug of type NumpyAxisMisuseTransformer-d2d6 starting at line 2, column 17 and ending at line 2, column 42.\n",
            "The bug can be fixed by substituting the bugged code-string <numpy.sum(data, axis = 1)> with the following code-string <numpy.sum(data, axis=16)>\n",
            "Debugging...\n",
            "clean_code\n",
            "data = numpy.array([[1, 2, 3], [4, 5, 6]])\n",
            "sum_along_axis = numpy.sum(data, axis=16)\n",
            "Checking if the debugged code is equal to the original code..\n",
            "The result of deep_equals between the concrete syntax tree of the original and debugged code is True\n"
          ]
        }
      ],
      "source": [
        "script = \"\"\"data = numpy.array([[1, 2, 3], [4, 5, 6]])\n",
        "sum_along_axis = numpy.sum(data, axis=16)\"\"\"\n",
        "transformers = [NumpyAxisMisuseTransformer]\n",
        "bugger_example(transformers,script)"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Chaining Multiple Bugs\n",
        "\n",
        "Bugs can be chained in a sequence and they are executed in an order, bugs do not modify nodes that have already been modified or that either their children or parent has been modified. As an example we are going to all InfiniteWhiletransformer, OffByKIndexTransformer and ComparisonTargetTransfomer over the script:\n",
        "\n",
        "while x == 1 + 2 == 3 + 2 != 3 + 4 > z[4]:  y = 1 + 2\\nx[1:2]\\nx[1]\\nx[1]==3 \n",
        "\n",
        "Comparison target and OffByKIndex only modify targets that are outside the while target statement."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 44,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "original_code\n",
            "while x == 1 + 2 == 3 + 2 != 3 + 4 > 3: \n",
            "  y = 1 + 2\n",
            "x[1:2]\n",
            "x[1]\n",
            "x[1]==3\n",
            "tainted_code\n",
            "while True: \n",
            "  y = 1 + 2\n",
            "x[2:3]\n",
            "x[2]\n",
            "x[2] >= 3\n",
            "The result of deep_equals between the concrete syntax tree of the original and the bugged code is False\n",
            "Checking for bugs...\n",
            "The following Node has a bug of type InfiniteWhileTransformer-21dd starting at line 1, column 0 and ending at line 2, column 11.\n",
            "The bug can be fixed by substituting the bugged code-string <while True: \n",
            "  y = 1 + 2\n",
            "> with the following code-string <while x == 1 + 2 == 3 + 2 != 3 + 4 > 3: \n",
            "  y = 1 + 2\n",
            ">\n",
            "The following Node has a bug of type OffByKIndexTransformer-1750 starting at line 3, column 2 and ending at line 3, column 5.\n",
            "The bug can be fixed by substituting the bugged code-string <2:3> with the following code-string <1:2>\n",
            "The following Node has a bug of type OffByKIndexTransformer-1750 starting at line 4, column 2 and ending at line 4, column 3.\n",
            "The bug can be fixed by substituting the bugged code-string <2> with the following code-string <1>\n",
            "The following Node has a bug of type OffByKIndexTransformer-1750 starting at line 5, column 2 and ending at line 5, column 3.\n",
            "The bug can be fixed by substituting the bugged code-string <2> with the following code-string <1>\n",
            "The following Node has a bug of type ComparisonTargetTransformer-8ff0 starting at line 5, column 4 and ending at line 5, column 9.\n",
            "The bug can be fixed by substituting the bugged code-string < >= 3> with the following code-string <==3>\n",
            "Debugging...\n",
            "clean_code\n",
            "while x == 1 + 2 == 3 + 2 != 3 + 4 > 3: \n",
            "  y = 1 + 2\n",
            "x[1:2]\n",
            "x[1]\n",
            "x[1]==3\n",
            "Checking if the debugged code is equal to the original code..\n",
            "The result of deep_equals between the concrete syntax tree of the original and debugged code is True\n"
          ]
        }
      ],
      "source": [
        "transformers = [InfiniteWhileTransformer,gen_OffByKIndexTransformer(1),gen_ComparisonTargetTransfomer(\"==\",\">=\")]\n",
        "# Get the script as a string\n",
        "script = \"while x == 1 + 2 == 3 + 2 != 3 + 4 > 3: \\n  y = 1 + 2\\nx[1:2]\\nx[1]\\nx[1]==3\"\n",
        "bugger_example(transformers,script)"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "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.10.6"
    },
    "orig_nbformat": 4,
    "vscode": {
      "interpreter": {
        "hash": "ceba285e8b4e6478fe8ad229bc63940a90ad5cf3d143521e7c38823a2e915b21"
      }
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}