Experiments.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "outputs": [],
   "source": [
    "from generation.GeneratedTestSaver import GeneratedTestSaver\n",
    "from history_scanner.GitHistoryDataSetParser import GitHistoryDataSetParser\n",
    "from generation.Model import Model"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "outputs": [],
   "source": [
    "# Load data\n",
    "parser = GitHistoryDataSetParser(\"dataset_repos/pydriller\", branch=\"master\")\n",
    "data = parser.load_data(\"dataset_repos/data/pydriller_commits.dat\")\n",
    "model = Model()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "created git_repository and other important classes: \n",
      "['CommitVisitor.py', 'git_repository.py']\n",
      "['git_repository_tests.py']\n",
      "\n",
      "git repo now has get_commit: \n",
      "['git_repository.py']\n",
      "['git_repository_tests.py']\n",
      "\n",
      "add modification, implemented files(): \n",
      "['modification.py', 'git_repository.py']\n",
      "['git_repository_tests.py']\n",
      "\n",
      "first visitor works!: \n",
      "['git_repository.py']\n",
      "['git_repository_tests.py']\n",
      "\n",
      "improvements on git_repository: \n",
      "['modification.py']\n",
      "['git_repository_tests.py']\n",
      "\n",
      "added filters. new tests too: \n",
      "['repository_mining.py']\n",
      "['git_repository_tests.py', 'repository_mining_tests.py']\n",
      "\n",
      "now it handles different branches: \n",
      "['git_repository.py']\n",
      "['git_repository_tests.py', 'repository_mining_tests.py']\n",
      "\n",
      "moving from unittest to pytest: \n",
      "['repository_mining.py']\n",
      "['test_git_repository.py', 'test_repository_mining.py']\n",
      "\n",
      "now it creates a new branch when checking out. More tests too: \n",
      "['commit.py', 'repository_mining.py', 'git_repository.py']\n",
      "['test_between_dates.py', 'test_dates_and_timezones.py', 'test_reverse_order.py', 'test_commit.py', 'test_git_repository.py', 'test_ranges.py']\n",
      "\n",
      "finish to replicate repodriller tests: \n",
      "['git_repository.py']\n",
      "['test_commit.py', 'test_git_repository.py']\n",
      "\n",
      "fix bug of timezones: \n",
      "['git_repository.py']\n",
      "['test_git_repository.py', 'test_memory_consumption.py']\n",
      "\n",
      "implemented commit filters: \n",
      "['repository_mining.py']\n",
      "['test_memory_consumption.py', 'test_ranges.py']\n",
      "\n",
      "structure changed. now everything is in pydriller: \n",
      "['repository_mining.py', 'commit_visitor.py']\n",
      "['concurrency_visitor_test.py', 'test_between_dates.py', 'test_between_tags.py', 'test_commit_filters.py', 'test_concurrency.py', 'test_dates_and_timezones.py', 'test_only_modification_with_file_type.py', 'test_reverse_order.py', 'test_commit.py', 'test_git_repository.py', 'test_memory_consumption.py', 'test_modification.py', 'test_ranges.py', 'visitor_test.py']\n",
      "\n",
      "big change: CommitVisitor is no longer needed. Now RepositoryMining returns a generator instead: \n",
      "['commit.py', 'modification.py']\n",
      "['test_between_dates.py', 'test_between_tags.py', 'test_commit_filters.py', 'test_concurrency.py', 'test_dates_and_timezones.py', 'test_only_modification_with_file_type.py', 'test_reverse_order.py', 'test_commit.py', 'test_git_repository.py', 'test_memory_consumption.py', 'test_modification.py', 'test_ranges.py']\n",
      "\n",
      "new feature parse_diff to parse a git diff: \n",
      "['git_repository.py']\n",
      "['test_diff.py', 'test_git_repository.py']\n",
      "\n",
      "now pydriller works for python >= 3.4: \n",
      "['repository_mining.py']\n",
      "['test_commit.py', 'test_diff.py', 'test_memory_consumption.py']\n",
      "\n",
      "fixing astimezone since it is not available for python < 3.6: \n",
      "['repository_mining.py']\n",
      "['test_memory_consumption.py']\n",
      "\n",
      "Modifications list is now a lazy property, and it is instantiated on the Commit instead of in RepositoryMining: \n",
      "['commit.py', 'git_repository.py']\n",
      "['test_git_repository.py']\n",
      "\n",
      "Now also branches is calculated lazily. Memory consumption test now tests both solution (with everything, and nothing): \n",
      "['commit.py']\n",
      "['test_memory_consumption.py']\n",
      "\n",
      "Major change: everything is lazy now, including the diff and the source code. Modification.py no longer exist, everything is in the commit module.: \n",
      "['commit.py']\n",
      "['test_commit.py', 'test_git_repository.py', 'test_memory_consumption.py']\n",
      "\n",
      "started implementing szz: \n",
      "['git_repository.py']\n",
      "['test_git_repository.py']\n",
      "\n",
      "speeding up PyDriller. Now it saves GitCommit object so it queries less time Git: \n",
      "['commit.py', 'git_repository.py', 'repository_mining.py']\n",
      "['test_git_repository.py']\n",
      "\n",
      "Rollback: Modifications are now simpler, and do not require to call git diff 2 times: \n",
      "['git_repository.py', 'repository_mining.py']\n",
      "['test_git_repository.py']\n",
      "\n",
      "new metrics in modification: \n",
      "['commit.py']\n",
      "['test_commit.py']\n",
      "\n",
      "now commit contains also the list of methods: \n",
      "['commit.py']\n",
      "['test_commit.py']\n",
      "\n",
      "small improvements\n",
      "\n",
      "using a more pythonic way to check if string is empty.\n",
      "removing logging from test_memory_consumption, not needed anymore.\n",
      "increasing the timing for travis, since it doesn't log anymore: \n",
      "['commit.py', 'git_repository.py']\n",
      "['test_memory_consumption.py']\n",
      "\n",
      "first attempt, added the possibility of passing a list of URLs instead of just 1: \n",
      "['repository_mining.py']\n",
      "['test_ranges.py']\n",
      "\n",
      "fix bugs in repository mining, add tests. Thank you tests!!: \n",
      "['repository_mining.py']\n",
      "['test_repository_mining.py']\n",
      "\n",
      "deleted one parameter, now the RepositoryMining accepts only path to repo, which might be local or remote: \n",
      "['repository_mining.py']\n",
      "['test_repository_mining.py']\n",
      "\n",
      "Commit now has information on the project name.\n",
      "reformatting using PyCharm: \n",
      "['commit.py', 'git_repository.py']\n",
      "['test_git_repository.py']\n",
      "\n",
      "small in comments: \n",
      "['repository_mining.py']\n",
      "['test_repository_mining.py']\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "KeyboardInterrupt\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Parse data\n",
    "parser = GitHistoryDataSetParser(\"dataset_repos/pydriller\", branch=\"master\")\n",
    "data = parser.parse_data()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "print(str(data[-5]))"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "print(\"\\n\".join(f.source for f in data[-5].test_files))"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "prompts = [prompt for prompt in data[-5].construct_prompt()]"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "generation = model.generate_test(str(prompts[0]))"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "def print_generation(generation):\n",
    "    for gen in generation:\n",
    "        print(gen)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "import ast\n",
    "parse = ast.parse(data[-5].source_files[0].source)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "def search_in_body(parse):\n",
    "    for expr in parse.body:\n",
    "        if isinstance(expr, ast.ClassDef):\n",
    "            print(expr.name)\n",
    "            search_in_body(expr)\n",
    "        if isinstance(expr, ast.FunctionDef):\n",
    "            print(expr.name)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "search_in_body(parse)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "# Fixing imports"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "import subprocess"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "out = subprocess.run(\"pytest C:\\\\Users\\\\Ivan\\\\PycharmProjects\\\\auto-test-generator\\\\dataset_repos\\\\pydriller\\\\generated_tests\\\\test_2929a6aa-63c3-423f-9cf9-bb20187aa9fd.py\", shell=True, stdout=subprocess.PIPE,cwd=\"C:\\\\Users\\\\Ivan\\\\PycharmProjects\\\\auto-test-generator\\\\dataset_repos\\\\pydriller\").stdout.decode()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "print(out)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "import re\n",
    "matches  = re.findall(r\"NameError:\\sname '(\\w+)' is not defined\", out)\n",
    "print(matches)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "pass_out = out = subprocess.run(\"pytest C:\\\\Users\\\\Ivan\\\\PycharmProjects\\\\auto-test-generator\\\\dataset_repos\\\\pydriller\\\\generated_tests\\\\test_2929a6aa-63c3-423f-9cf9-bb20187aa9fd.py\", shell=True, stdout=subprocess.PIPE,cwd=\"C:\\\\Users\\\\Ivan\\\\PycharmProjects\\\\auto-test-generator\\\\dataset_repos\\\\pydriller\").stdout.decode()\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "def extract_group(tup):\n",
    "        return [i for i in tup if i is not None]"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "#print(out)\n",
    "errors = re.search(r\"((?P<failedNumber>\\d)+ failed)|((?P<passedNumber>\\d+) passed)|((?P<warningsNumber>\\d+) warning)|((?P<errorNumber>\\d+) error)/g\", out)\n",
    "reg = re.compile(r'=.+((?P<failedNumber>\\d+) warning)')\n",
    "print(reg.search(out).groups('failedNumber')[1])"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Crawling for import"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "import os\n",
    "base_dir = \"C:\\\\Users\\\\Ivan\\\\PycharmProjects\\\\auto-test-generator\\\\dataset_repos\\\\pydriller\""
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "listOfFiles = list()\n",
    "for (dirpath, dirnames, filenames) in os.walk(base_dir):\n",
    "    listOfFiles += [os.path.join(dirpath, file) for file in filenames if file.endswith(\".py\")]\n",
    "print(listOfFiles)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "def find_import(files, searched_entries):\n",
    "    for file in files:\n",
    "        with open(file, 'r') as f:\n",
    "            head = f.readlines()\n",
    "        for line in head:\n",
    "            found_strings = []\n",
    "            for s in searched_entries:\n",
    "                if f'import' in line and s in line:\n",
    "                    print(line)\n",
    "                    found_strings.append(s)\n",
    "            [searched_entries.remove(s) for s in found_strings]\n",
    "        if len(searched_entries) == 0:\n",
    "            break"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "find_import(listOfFiles, set(matches))"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "# Model improvements"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "outputs": [],
   "source": [
    "prompt = '''\n",
    "# Copyright 2018 Davide Spadini\n",
    "#\n",
    "# Licensed under the Apache License, Version 2.0 (the \"License\");\n",
    "# you may not use this file except in compliance with the License.\n",
    "# You may obtain a copy of the License at\n",
    "#\n",
    "#    http://www.apache.org/licenses/LICENSE-2.0\n",
    "#\n",
    "# Unless required by applicable law or agreed to in writing, software\n",
    "# distributed under the License is distributed on an \"AS IS\" BASIS,\n",
    "# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
    "# See the License for the specific language governing permissions and\n",
    "# limitations under the License.\n",
    "\n",
    "\"\"\"\n",
    "This module contains all the classes regarding a specific commit, such as\n",
    "Commit, Modification,\n",
    "ModificationType and Method.\n",
    "\"\"\"\n",
    "\n",
    "import logging\n",
    "from _datetime import datetime\n",
    "from enum import Enum\n",
    "from pathlib import Path\n",
    "from typing import List, Set, Dict\n",
    "\n",
    "import lizard\n",
    "from git import Repo, Diff, Git, Commit as GitCommit\n",
    "\n",
    "from pydriller.domain.developer import Developer\n",
    "\n",
    "logger = logging.getLogger(__name__)\n",
    "\n",
    "NULL_TREE = '4b825dc642cb6eb9a060e54bf8d69288fbee4904'\n",
    "\n",
    "\n",
    "class ModificationType(Enum):\n",
    "    \"\"\"\n",
    "    Type of Modification. Can be ADD, COPY, RENAME, DELETE, MODIFY or UNKNOWN.\n",
    "    \"\"\"\n",
    "\n",
    "    ADD = 1\n",
    "    COPY = 2\n",
    "    RENAME = 3\n",
    "    DELETE = 4\n",
    "    MODIFY = 5\n",
    "    UNKNOWN = 6\n",
    "\n",
    "\n",
    "class Method:  # pylint: disable=R0902\n",
    "    \"\"\"\n",
    "    This class represents a method in a class. Contains various information\n",
    "    extracted through Lizard.\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, func):\n",
    "        \"\"\"\n",
    "        Initialize a method object. This is calculated using Lizard: it parses\n",
    "        the source code of all the modifications in a commit, extracting\n",
    "        information of the methods contained in the file (if the file is a\n",
    "        source code written in one of the supported programming languages).\n",
    "        \"\"\"\n",
    "\n",
    "        self.name = func.name\n",
    "        self.long_name = func.long_name\n",
    "        self.filename = func.filename\n",
    "        self.nloc = func.nloc\n",
    "        self.complexity = func.cyclomatic_complexity\n",
    "        self.token_count = func.token_count\n",
    "        self.parameters = func.parameters\n",
    "        self.start_line = func.start_line\n",
    "        self.end_line = func.end_line\n",
    "        self.fan_in = func.fan_in\n",
    "        self.fan_out = func.fan_out\n",
    "        self.general_fan_out = func.general_fan_out\n",
    "        self.length = func.length\n",
    "        self.top_nesting_level = func.top_nesting_level\n",
    "\n",
    "\n",
    "class Modification:  # pylint: disable=R0902\n",
    "    \"\"\"\n",
    "    This class contains information regarding a modified file in a commit.\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, old_path: str, new_path: str,\n",
    "                 change_type: ModificationType,\n",
    "                 diff_and_sc: Dict[str, str]):\n",
    "        \"\"\"\n",
    "        Initialize a modification. A modification carries on information\n",
    "        regarding the changed file. Normally, you shouldn't initialize a new\n",
    "        one.\n",
    "        \"\"\"\n",
    "        self._old_path = Path(old_path) if old_path is not None else None\n",
    "        self._new_path = Path(new_path) if new_path is not None else None\n",
    "        self.change_type = change_type\n",
    "        self.diff = diff_and_sc['diff']\n",
    "        self.source_code = diff_and_sc['source_code']\n",
    "        self.source_code_before = diff_and_sc['source_code_before']\n",
    "\n",
    "        self._nloc = None\n",
    "        self._complexity = None\n",
    "        self._token_count = None\n",
    "        self._function_list = []\n",
    "\n",
    "    @property\n",
    "    def added(self) -> int:\n",
    "        \"\"\"\n",
    "        Return the total number of added lines in the file.\n",
    "\n",
    "        :return: int lines_added\n",
    "        \"\"\"\n",
    "        added = 0\n",
    "        for line in self.diff.replace('\\r', '').split(\"\\n\"):\n",
    "            if line.startswith('+') and not line.startswith('+++'):\n",
    "                added += 1\n",
    "        return added\n",
    "\n",
    "    @property\n",
    "    def removed(self):\n",
    "        \"\"\"\n",
    "        Return the total number of deleted lines in the file.\n",
    "\n",
    "        :return: int lines_deleted\n",
    "        \"\"\"\n",
    "        removed = 0\n",
    "        for line in self.diff.replace('\\r', '').split(\"\\n\"):\n",
    "            if line.startswith('-') and not line.startswith('---'):\n",
    "                removed += 1\n",
    "        return removed\n",
    "\n",
    "    @property\n",
    "    def old_path(self):\n",
    "        \"\"\"\n",
    "        Old path of the file. Can be None if the file is added.\n",
    "\n",
    "        :return: str old_path\n",
    "        \"\"\"\n",
    "        if self._old_path:\n",
    "            return str(self._old_path)\n",
    "        return self._old_path\n",
    "\n",
    "    @property\n",
    "    def new_path(self):\n",
    "        \"\"\"\n",
    "        New path of the file. Can be None if the file is deleted.\n",
    "\n",
    "        :return: str new_path\n",
    "        \"\"\"\n",
    "        if self._new_path:\n",
    "            return str(self._new_path)\n",
    "        return self._new_path\n",
    "\n",
    "    @property\n",
    "    def filename(self) -> str:\n",
    "        \"\"\"\n",
    "        Return the filename. Given a path-like-string (e.g.\n",
    "        \"/Users/dspadini/pydriller/myfile.py\") returns only the filename\n",
    "        (e.g. \"myfile.py\")\n",
    "\n",
    "        :return: str filename\n",
    "        \"\"\"\n",
    "        if self._new_path is not None and str(self._new_path) != \"/dev/null\":\n",
    "            path = self._new_path\n",
    "        else:\n",
    "            path = self._old_path\n",
    "\n",
    "        return path.name\n",
    "\n",
    "    @property\n",
    "    def nloc(self) -> int:\n",
    "        \"\"\"\n",
    "        Calculate the LOC of the file.\n",
    "\n",
    "        :return: LOC of the file\n",
    "        \"\"\"\n",
    "        self._calculate_metrics()\n",
    "        return self._nloc\n",
    "\n",
    "    @property\n",
    "    def complexity(self) -> int:\n",
    "        \"\"\"\n",
    "        Calculate the Cyclomatic Complexity of the file.\n",
    "\n",
    "        :return: Cyclomatic Complexity of the file\n",
    "        \"\"\"\n",
    "        self._calculate_metrics()\n",
    "        return self._complexity\n",
    "\n",
    "    @property\n",
    "    def token_count(self) -> int:\n",
    "        \"\"\"\n",
    "        Calculate the token count of functions.\n",
    "\n",
    "        :return: token count\n",
    "        \"\"\"\n",
    "        self._calculate_metrics()\n",
    "        return self._token_count\n",
    "\n",
    "    @property\n",
    "    def methods(self) -> List[Method]:\n",
    "        \"\"\"\n",
    "        Return the list of methods in the file. Every method\n",
    "        contains various information like complexity, loc, name,\n",
    "        number of parameters, etc.\n",
    "\n",
    "        :return: list of methods\n",
    "        \"\"\"\n",
    "        self._calculate_metrics()\n",
    "        return self._function_list\n",
    "\n",
    "    def _calculate_metrics(self):\n",
    "        if self.source_code and self._nloc is None:\n",
    "            l = lizard.analyze_file.analyze_source_code(self.filename,\n",
    "                                                        self.source_code)\n",
    "\n",
    "            self._nloc = l.nloc\n",
    "            self._complexity = l.CCN\n",
    "            self._token_count = l.token_count\n",
    "\n",
    "            for func in l.function_list:\n",
    "                self._function_list.append(Method(func))\n",
    "\n",
    "    def __eq__(self, other):\n",
    "        if not isinstance(other, Modification):\n",
    "            return NotImplemented\n",
    "        if self is other:\n",
    "            return True\n",
    "        return self.__dict__ == other.__dict__\n",
    "\n",
    "    def __str__(self): # pragma: no cover\n",
    "        return (\n",
    "            'MODIFICATION\\n' +\n",
    "            'Old Path: {}\\n'.format(self.old_path) +\n",
    "            'New Path: {}\\n'.format(self.new_path) +\n",
    "            'Type: {}\\n'.format(self.change_type.name) +\n",
    "            'Diff: {}\\n'.format(self.diff) +\n",
    "            'Source code before: {}\\n'.format(self.source_code_before) +\n",
    "            'Source code: {}\\n'.format(self.source_code)\n",
    "        )\n",
    "\n",
    "\n",
    "class Commit:\n",
    "    \"\"\"\n",
    "    Class representing a Commit. Contains all the important information such\n",
    "    as hash, author, dates, and modified files.\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, commit: GitCommit, project_path: Path,\n",
    "                 main_branch: str) -> None:\n",
    "        \"\"\"\n",
    "        Create a commit object.\n",
    "\n",
    "        :param commit: GitPython Commit object\n",
    "        :param project_path: path to the project (temporary folder in case\n",
    "            of a remote repository)\n",
    "        :param main_branch: main branch of the repo\n",
    "        \"\"\"\n",
    "        self._c_object = commit\n",
    "        self._main_branch = main_branch\n",
    "        self.project_path = project_path\n",
    "\n",
    "        self._modifications = None\n",
    "        self._branches = None\n",
    "\n",
    "    @property\n",
    "    def hash(self) -> str:\n",
    "        \"\"\"\n",
    "        Return the SHA of the commit.\n",
    "\n",
    "        :return: str hash\n",
    "        \"\"\"\n",
    "        return self._c_object.hexsha\n",
    "\n",
    "    @property\n",
    "    def author(self) -> Developer:\n",
    "        \"\"\"\n",
    "        Return the author of the commit as a Developer object.\n",
    "\n",
    "        :return: author\n",
    "        \"\"\"\n",
    "        return Developer(self._c_object.author.name,\n",
    "                         self._c_object.author.email)\n",
    "\n",
    "    @property\n",
    "    def committer(self) -> Developer:\n",
    "        \"\"\"\n",
    "        Return the committer of the commit as a Developer object.\n",
    "\n",
    "        :return: committer\n",
    "        \"\"\"\n",
    "        return Developer(self._c_object.committer.name,\n",
    "                         self._c_object.committer.email)\n",
    "\n",
    "    @property\n",
    "    def project_name(self) -> str:\n",
    "        \"\"\"\n",
    "        Return the project name.\n",
    "\n",
    "        :return: project name\n",
    "        \"\"\"\n",
    "        return self.project_path.name\n",
    "\n",
    "    @property\n",
    "    def author_date(self) -> datetime:\n",
    "        \"\"\"\n",
    "        Return the authored datetime.\n",
    "\n",
    "        :return: datetime author_datetime\n",
    "        \"\"\"\n",
    "        return self._c_object.authored_datetime\n",
    "\n",
    "    @property\n",
    "    def committer_date(self) -> datetime:\n",
    "        \"\"\"\n",
    "        Return the committed datetime.\n",
    "\n",
    "        :return: datetime committer_datetime\n",
    "        \"\"\"\n",
    "        return self._c_object.committed_datetime\n",
    "\n",
    "    @property\n",
    "    def author_timezone(self) -> int:\n",
    "        \"\"\"\n",
    "        Author timezone expressed in seconds from epoch.\n",
    "\n",
    "        :return: int timezone\n",
    "        \"\"\"\n",
    "        return self._c_object.author_tz_offset\n",
    "\n",
    "    @property\n",
    "    def committer_timezone(self) -> int:\n",
    "        \"\"\"\n",
    "        Author timezone expressed in seconds from epoch.\n",
    "\n",
    "        :return: int timezone\n",
    "        \"\"\"\n",
    "        return self._c_object.committer_tz_offset\n",
    "\n",
    "    @property\n",
    "    def msg(self) -> str:\n",
    "        \"\"\"\n",
    "        Return commit message.\n",
    "\n",
    "        :return: str commit_message\n",
    "        \"\"\"\n",
    "        return self._c_object.message.strip()\n",
    "\n",
    "    @property\n",
    "    def parents(self) -> List[str]:\n",
    "        \"\"\"\n",
    "        Return the list of parents SHAs.\n",
    "\n",
    "        :return: List[str] parents\n",
    "        \"\"\"\n",
    "        parents = []\n",
    "        for p in self._c_object.parents:\n",
    "            parents.append(p.hexsha)\n",
    "        return parents\n",
    "\n",
    "    @property\n",
    "    def merge(self) -> bool:\n",
    "        \"\"\"\n",
    "        Return True if the commit is a merge, False otherwise.\n",
    "\n",
    "        :return: bool merge\n",
    "        \"\"\"\n",
    "        return len(self._c_object.parents) > 1\n",
    "\n",
    "    @property\n",
    "    def modifications(self) -> List[Modification]:\n",
    "        \"\"\"\n",
    "        Return a list of modified files.\n",
    "\n",
    "        :return: List[Modification] modifications\n",
    "        \"\"\"\n",
    "        if self._modifications is None:\n",
    "            self._modifications = self._get_modifications()\n",
    "\n",
    "        return self._modifications\n",
    "\n",
    "    def _get_modifications(self):\n",
    "        repo = Repo(str(self.project_path))\n",
    "        commit = self._c_object\n",
    "\n",
    "        if len(self.parents) == 1:\n",
    "            # the commit has a parent\n",
    "            diff_index = self._c_object.parents[0].diff(commit,\n",
    "                                                        create_patch=True)\n",
    "        elif len(self.parents) > 1:\n",
    "            # if it's a merge commit, the modified files of the commit are the\n",
    "            # conflicts. This because if the file is not in conflict,\n",
    "            # pydriller will visit the modification in one of the previous\n",
    "            # commits. However, parsing the output of a combined diff (that\n",
    "            # returns the list of conflicts) is challenging: so, right now,\n",
    "            # I will return an empty array, in the meanwhile I will try to\n",
    "            # find a way to parse the output.\n",
    "            # c_git = Git(str(self.project_path))\n",
    "            # d = c_git.diff_tree(\"--cc\", commit.hexsha, '-r', '--abbrev=40',\n",
    "            #                     '--full-index', '-M', '-p', '--no-color')\n",
    "            diff_index = []\n",
    "        else:\n",
    "            # this is the first commit of the repo. Comparing it with git\n",
    "            # NULL TREE\n",
    "            parent = repo.tree(NULL_TREE)\n",
    "            diff_index = parent.diff(commit.tree, create_patch=True)\n",
    "\n",
    "        return self._parse_diff(diff_index)\n",
    "\n",
    "    def _parse_diff(self, diff_index) -> List[Modification]:\n",
    "        modifications_list = []\n",
    "        for diff in diff_index:\n",
    "            old_path = diff.a_path\n",
    "            new_path = diff.b_path\n",
    "            change_type = self._from_change_to_modification_type(diff)\n",
    "\n",
    "            diff_and_sc = {\n",
    "                'diff': self._get_decoded_str(diff.diff),\n",
    "                'source_code_before': self._get_decoded_sc_str(\n",
    "                    diff.a_blob),\n",
    "                'source_code': self._get_decoded_sc_str(\n",
    "                    diff.b_blob)\n",
    "            }\n",
    "\n",
    "            modifications_list.append(Modification(old_path, new_path,\n",
    "                                                   change_type, diff_and_sc))\n",
    "\n",
    "        return modifications_list\n",
    "\n",
    "    def _get_decoded_str(self, diff):\n",
    "        try:\n",
    "            return diff.decode('utf-8', 'ignore')\n",
    "        except (UnicodeDecodeError, AttributeError, ValueError):\n",
    "            logger.debug('Could not load the diff of a '\n",
    "                         'file in commit %s', self._c_object.hexsha)\n",
    "            return None\n",
    "\n",
    "    def _get_decoded_sc_str(self, diff):\n",
    "        try:\n",
    "            return diff.data_stream.read().decode('utf-8', 'ignore')\n",
    "        except (UnicodeDecodeError, AttributeError, ValueError):\n",
    "            logger.debug('Could not load source code of a '\n",
    "                         'file in commit %s', self._c_object.hexsha)\n",
    "            return None\n",
    "\n",
    "    @property\n",
    "    def in_main_branch(self) -> bool:\n",
    "        \"\"\"\n",
    "        Return True if the commit is in the main branch, False otherwise.\n",
    "\n",
    "        :return: bool in_main_branch\n",
    "        \"\"\"\n",
    "        return self._main_branch in self.branches\n",
    "\n",
    "    @property\n",
    "    def branches(self) -> Set[str]:\n",
    "        \"\"\"\n",
    "        Return the set of branches that contain the commit.\n",
    "\n",
    "        :return: set(str) branches\n",
    "        \"\"\"\n",
    "        if self._branches is None:\n",
    "            self._branches = self._get_branches()\n",
    "\n",
    "        return self._branches\n",
    "\n",
    "    def _get_branches(self):\n",
    "        c_git = Git(str(self.project_path))\n",
    "        branches = set()\n",
    "        for branch in set(c_git.branch('--contains', self.hash).split('\\n')):\n",
    "            branches.add(branch.strip().replace('* ', ''))\n",
    "        return branches\n",
    "\n",
    "    # pylint disable=R0902\n",
    "    def _from_change_to_modification_type(self, diff: Diff):\n",
    "        if diff.new_file:\n",
    "            return ModificationType.ADD\n",
    "        if diff.deleted_file:\n",
    "            return ModificationType.DELETE\n",
    "        if diff.renamed_file:\n",
    "            return ModificationType.RENAME\n",
    "        if diff.a_blob and diff.b_blob and diff.a_blob != diff.b_blob:\n",
    "            return ModificationType.MODIFY\n",
    "\n",
    "        return ModificationType.UNKNOWN\n",
    "\n",
    "    def __eq__(self, other):\n",
    "        if not isinstance(other, Commit):\n",
    "            return NotImplemented\n",
    "        if self is other:\n",
    "            return True\n",
    "\n",
    "        return self.__dict__ == other.__dict__\n",
    "\n",
    "    def __str__(self): # pragma: no cover\n",
    "        return (\n",
    "            'Hash: {}\\n'.format(self.hash) +\n",
    "            'Author: {}\\n'.format(self.author.name) +\n",
    "            'Author email: {}\\n'.format(self.author.email) +\n",
    "            'Committer: {}\\n'.format(self.committer.name) +\n",
    "            'Committer email: {}\\n'.format(self.committer.email) +\n",
    "            'Author date: {}\\n'.format(\n",
    "                self.author_date.strftime(\"%Y-%m-%d %H:%M:%S\")) +\n",
    "            'Committer date: {}\\n'.format(\n",
    "                self.committer_date.strftime(\"%Y-%m-%d %H:%M:%S\")) +\n",
    "            'Message: {}\\n'.format(self.msg) +\n",
    "            'Parent: {}\\n'.format(\"\\n\".join(map(str, self.parents))) +\n",
    "            'Merge: {}\\n'.format(self.merge) +\n",
    "            'Modifications: \\n{}'.format(\n",
    "                \"\\n\".join(map(str, self.modifications))) +\n",
    "            'Branches: \\n{}'.format(\"\\n\".join(map(str, self.branches))) +\n",
    "            'In main branch: {}\\n'.format(self.in_main_branch)\n",
    "        )\n",
    "\"\"\"\n",
    "Test which tests class Commit and dmm_unit_complexity. For the test use test-repos/dmm-test-repo. Assert the dmm_unit_complexity to be 1.0\n",
    "\"\"\"\n",
    "def test_\n",
    "'''"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\n",
      "  \"choices\": [\n",
      "    {\n",
      "      \"finish_reason\": \"length\",\n",
      "      \"index\": 0,\n",
      "      \"logprobs\": null,\n",
      "      \"text\": \"\\n# Copyright 2018 Davide Spadini\\n#\\n# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n# you may not use this file except in compliance with the License.\\n# You may obtain a copy of the License at\\n#\\n#    http://www.apache.org/licenses/LICENSE-2.0\\n#\\n# Unless required by applicable law or agreed to in writing, software\\n# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n# See the License for the specific language governing permissions and\\n# limitations under the License.\\n\\n\\\"\\\"\\\"\\nThis module contains all the classes regarding a specific commit, such as\\nCommit, Modification,\\nModificationType and Method.\\n\\\"\\\"\\\"\\n\\nimport logging\\nfrom _datetime import datetime\\nfrom enum import Enum\\nfrom pathlib import Path\\nfrom typing import List, Set, Dict\\n\\nimport lizard\\nfrom git import Repo, Diff, Git, Commit as GitCommit\\n\\nfrom pydriller.domain.developer import Developer\\n\\nlogger = logging.getLogger(__name__)\\n\\nNULL_TREE = '4b825dc642cb6eb9a060e54bf8d69288fbee4904'\\n\\n\\nclass ModificationType(Enum):\\n    \\\"\\\"\\\"\\n    Type of Modification. Can be ADD, COPY, RENAME, DELETE, MODIFY or UNKNOWN.\\n    \\\"\\\"\\\"\\n\\n    ADD = 1\\n    COPY = 2\\n    RENAME = 3\\n    DELETE = 4\\n    MODIFY = 5\\n    UNKNOWN = 6\\n\\n\\nclass Method:  # pylint: disable=R0902\\n    \\\"\\\"\\\"\\n    This class represents a method in a class. Contains various information\\n    extracted through Lizard.\\n    \\\"\\\"\\\"\\n\\n    def __init__(self, func):\\n        \\\"\\\"\\\"\\n        Initialize a method object. This is calculated using Lizard: it parses\\n        the source code of all the modifications in a commit, extracting\\n        information of the methods contained in the file (if the file is a\\n        source code written in one of the supported programming languages).\\n        \\\"\\\"\\\"\\n\\n        self.name = func.name\\n        self.long_name = func.long_name\\n        self.filename = func.filename\\n        self.nloc = func.nloc\\n        self.complexity = func.cyclomatic_complexity\\n        self.token_count = func.token_count\\n        self.parameters = func.parameters\\n        self.start_line = func.start_line\\n        self.end_line = func.end_line\\n        self.fan_in = func.fan_in\\n        self.fan_out = func.fan_out\\n        self.general_fan_out = func.general_fan_out\\n        self.length = func.length\\n        self.top_nesting_level = func.top_nesting_level\\n\\n\\nclass Modification:  # pylint: disable=R0902\\n    \\\"\\\"\\\"\\n    This class contains information regarding a modified file in a commit.\\n    \\\"\\\"\\\"\\n\\n    def __init__(self, old_path: str, new_path: str,\\n                 change_type: ModificationType,\\n                 diff_and_sc: Dict[str, str]):\\n        \\\"\\\"\\\"\\n        Initialize a modification. A modification carries on information\\n        regarding the changed file. Normally, you shouldn't initialize a new\\n        one.\\n        \\\"\\\"\\\"\\n        self._old_path = Path(old_path) if old_path is not None else None\\n        self._new_path = Path(new_path) if new_path is not None else None\\n        self.change_type = change_type\\n        self.diff = diff_and_sc['diff']\\n        self.source_code = diff_and_sc['source_code']\\n        self.source_code_before = diff_and_sc['source_code_before']\\n\\n        self._nloc = None\\n        self._complexity = None\\n        self._token_count = None\\n        self._function_list = []\\n\\n    @property\\n    def added(self) -> int:\\n        \\\"\\\"\\\"\\n        Return the total number of added lines in the file.\\n\\n        :return: int lines_added\\n        \\\"\\\"\\\"\\n        added = 0\\n        for line in self.diff.replace('\\r', '').split(\\\"\\n\\\"):\\n            if line.startswith('+') and not line.startswith('+++'):\\n                added += 1\\n        return added\\n\\n    @property\\n    def removed(self):\\n        \\\"\\\"\\\"\\n        Return the total number of deleted lines in the file.\\n\\n        :return: int lines_deleted\\n        \\\"\\\"\\\"\\n        removed = 0\\n        for line in self.diff.replace('\\r', '').split(\\\"\\n\\\"):\\n            if line.startswith('-') and not line.startswith('---'):\\n                removed += 1\\n        return removed\\n\\n    @property\\n    def old_path(self):\\n        \\\"\\\"\\\"\\n        Old path of the file. Can be None if the file is added.\\n\\n        :return: str old_path\\n        \\\"\\\"\\\"\\n        if self._old_path:\\n            return str(self._old_path)\\n        return self._old_path\\n\\n    @property\\n    def new_path(self):\\n        \\\"\\\"\\\"\\n        New path of the file. Can be None if the file is deleted.\\n\\n        :return: str new_path\\n        \\\"\\\"\\\"\\n        if self._new_path:\\n            return str(self._new_path)\\n        return self._new_path\\n\\n    @property\\n    def filename(self) -> str:\\n        \\\"\\\"\\\"\\n        Return the filename. Given a path-like-string (e.g.\\n        \\\"/Users/dspadini/pydriller/myfile.py\\\") returns only the filename\\n        (e.g. \\\"myfile.py\\\")\\n\\n        :return: str filename\\n        \\\"\\\"\\\"\\n        if self._new_path is not None and str(self._new_path) != \\\"/dev/null\\\":\\n            path = self._new_path\\n        else:\\n            path = self._old_path\\n\\n        return path.name\\n\\n    @property\\n    def nloc(self) -> int:\\n        \\\"\\\"\\\"\\n        Calculate the LOC of the file.\\n\\n        :return: LOC of the file\\n        \\\"\\\"\\\"\\n        self._calculate_metrics()\\n        return self._nloc\\n\\n    @property\\n    def complexity(self) -> int:\\n        \\\"\\\"\\\"\\n        Calculate the Cyclomatic Complexity of the file.\\n\\n        :return: Cyclomatic Complexity of the file\\n        \\\"\\\"\\\"\\n        self._calculate_metrics()\\n        return self._complexity\\n\\n    @property\\n    def token_count(self) -> int:\\n        \\\"\\\"\\\"\\n        Calculate the token count of functions.\\n\\n        :return: token count\\n        \\\"\\\"\\\"\\n        self._calculate_metrics()\\n        return self._token_count\\n\\n    @property\\n    def methods(self) -> List[Method]:\\n        \\\"\\\"\\\"\\n        Return the list of methods in the file. Every method\\n        contains various information like complexity, loc, name,\\n        number of parameters, etc.\\n\\n        :return: list of methods\\n        \\\"\\\"\\\"\\n        self._calculate_metrics()\\n        return self._function_list\\n\\n    def _calculate_metrics(self):\\n        if self.source_code and self._nloc is None:\\n            l = lizard.analyze_file.analyze_source_code(self.filename,\\n                                                        self.source_code)\\n\\n            self._nloc = l.nloc\\n            self._complexity = l.CCN\\n            self._token_count = l.token_count\\n\\n            for func in l.function_list:\\n                self._function_list.append(Method(func))\\n\\n    def __eq__(self, other):\\n        if not isinstance(other, Modification):\\n            return NotImplemented\\n        if self is other:\\n            return True\\n        return self.__dict__ == other.__dict__\\n\\n    def __str__(self): # pragma: no cover\\n        return (\\n            'MODIFICATION\\n' +\\n            'Old Path: {}\\n'.format(self.old_path) +\\n            'New Path: {}\\n'.format(self.new_path) +\\n            'Type: {}\\n'.format(self.change_type.name) +\\n            'Diff: {}\\n'.format(self.diff) +\\n            'Source code before: {}\\n'.format(self.source_code_before) +\\n            'Source code: {}\\n'.format(self.source_code)\\n        )\\n\\n\\nclass Commit:\\n    \\\"\\\"\\\"\\n    Class representing a Commit. Contains all the important information such\\n    as hash, author, dates, and modified files.\\n    \\\"\\\"\\\"\\n\\n    def __init__(self, commit: GitCommit, project_path: Path,\\n                 main_branch: str) -> None:\\n        \\\"\\\"\\\"\\n        Create a commit object.\\n\\n        :param commit: GitPython Commit object\\n        :param project_path: path to the project (temporary folder in case\\n            of a remote repository)\\n        :param main_branch: main branch of the repo\\n        \\\"\\\"\\\"\\n        self._c_object = commit\\n        self._main_branch = main_branch\\n        self.project_path = project_path\\n\\n        self._modifications = None\\n        self._branches = None\\n\\n    @property\\n    def hash(self) -> str:\\n        \\\"\\\"\\\"\\n        Return the SHA of the commit.\\n\\n        :return: str hash\\n        \\\"\\\"\\\"\\n        return self._c_object.hexsha\\n\\n    @property\\n    def author(self) -> Developer:\\n        \\\"\\\"\\\"\\n        Return the author of the commit as a Developer object.\\n\\n        :return: author\\n        \\\"\\\"\\\"\\n        return Developer(self._c_object.author.name,\\n                         self._c_object.author.email)\\n\\n    @property\\n    def committer(self) -> Developer:\\n        \\\"\\\"\\\"\\n        Return the committer of the commit as a Developer object.\\n\\n        :return: committer\\n        \\\"\\\"\\\"\\n        return Developer(self._c_object.committer.name,\\n                         self._c_object.committer.email)\\n\\n    @property\\n    def project_name(self) -> str:\\n        \\\"\\\"\\\"\\n        Return the project name.\\n\\n        :return: project name\\n        \\\"\\\"\\\"\\n        return self.project_path.name\\n\\n    @property\\n    def author_date(self) -> datetime:\\n        \\\"\\\"\\\"\\n        Return the authored datetime.\\n\\n        :return: datetime author_datetime\\n        \\\"\\\"\\\"\\n        return self._c_object.authored_datetime\\n\\n    @property\\n    def committer_date(self) -> datetime:\\n        \\\"\\\"\\\"\\n        Return the committed datetime.\\n\\n        :return: datetime committer_datetime\\n        \\\"\\\"\\\"\\n        return self._c_object.committed_datetime\\n\\n    @property\\n    def author_timezone(self) -> int:\\n        \\\"\\\"\\\"\\n        Author timezone expressed in seconds from epoch.\\n\\n        :return: int timezone\\n        \\\"\\\"\\\"\\n        return self._c_object.author_tz_offset\\n\\n    @property\\n    def committer_timezone(self) -> int:\\n        \\\"\\\"\\\"\\n        Author timezone expressed in seconds from epoch.\\n\\n        :return: int timezone\\n        \\\"\\\"\\\"\\n        return self._c_object.committer_tz_offset\\n\\n    @property\\n    def msg(self) -> str:\\n        \\\"\\\"\\\"\\n        Return commit message.\\n\\n        :return: str commit_message\\n        \\\"\\\"\\\"\\n        return self._c_object.message.strip()\\n\\n    @property\\n    def parents(self) -> List[str]:\\n        \\\"\\\"\\\"\\n        Return the list of parents SHAs.\\n\\n        :return: List[str] parents\\n        \\\"\\\"\\\"\\n        parents = []\\n        for p in self._c_object.parents:\\n            parents.append(p.hexsha)\\n        return parents\\n\\n    @property\\n    def merge(self) -> bool:\\n        \\\"\\\"\\\"\\n        Return True if the commit is a merge, False otherwise.\\n\\n        :return: bool merge\\n        \\\"\\\"\\\"\\n        return len(self._c_object.parents) > 1\\n\\n    @property\\n    def modifications(self) -> List[Modification]:\\n        \\\"\\\"\\\"\\n        Return a list of modified files.\\n\\n        :return: List[Modification] modifications\\n        \\\"\\\"\\\"\\n        if self._modifications is None:\\n            self._modifications = self._get_modifications()\\n\\n        return self._modifications\\n\\n    def _get_modifications(self):\\n        repo = Repo(str(self.project_path))\\n        commit = self._c_object\\n\\n        if len(self.parents) == 1:\\n            # the commit has a parent\\n            diff_index = self._c_object.parents[0].diff(commit,\\n                                                        create_patch=True)\\n        elif len(self.parents) > 1:\\n            # if it's a merge commit, the modified files of the commit are the\\n            # conflicts. This because if the file is not in conflict,\\n            # pydriller will visit the modification in one of the previous\\n            # commits. However, parsing the output of a combined diff (that\\n            # returns the list of conflicts) is challenging: so, right now,\\n            # I will return an empty array, in the meanwhile I will try to\\n            # find a way to parse the output.\\n            # c_git = Git(str(self.project_path))\\n            # d = c_git.diff_tree(\\\"--cc\\\", commit.hexsha, '-r', '--abbrev=40',\\n            #                     '--full-index', '-M', '-p', '--no-color')\\n            diff_index = []\\n        else:\\n            # this is the first commit of the repo. Comparing it with git\\n            # NULL TREE\\n            parent = repo.tree(NULL_TREE)\\n            diff_index = parent.diff(commit.tree, create_patch=True)\\n\\n        return self._parse_diff(diff_index)\\n\\n    def _parse_diff(self, diff_index) -> List[Modification]:\\n        modifications_list = []\\n        for diff in diff_index:\\n            old_path = diff.a_path\\n            new_path = diff.b_path\\n            change_type = self._from_change_to_modification_type(diff)\\n\\n            diff_and_sc = {\\n                'diff': self._get_decoded_str(diff.diff),\\n                'source_code_before': self._get_decoded_sc_str(\\n                    diff.a_blob),\\n                'source_code': self._get_decoded_sc_str(\\n                    diff.b_blob)\\n            }\\n\\n            modifications_list.append(Modification(old_path, new_path,\\n                                                   change_type, diff_and_sc))\\n\\n        return modifications_list\\n\\n    def _get_decoded_str(self, diff):\\n        try:\\n            return diff.decode('utf-8', 'ignore')\\n        except (UnicodeDecodeError, AttributeError, ValueError):\\n            logger.debug('Could not load the diff of a '\\n                         'file in commit %s', self._c_object.hexsha)\\n            return None\\n\\n    def _get_decoded_sc_str(self, diff):\\n        try:\\n            return diff.data_stream.read().decode('utf-8', 'ignore')\\n        except (UnicodeDecodeError, AttributeError, ValueError):\\n            logger.debug('Could not load source code of a '\\n                         'file in commit %s', self._c_object.hexsha)\\n            return None\\n\\n    @property\\n    def in_main_branch(self) -> bool:\\n        \\\"\\\"\\\"\\n        Return True if the commit is in the main branch, False otherwise.\\n\\n        :return: bool in_main_branch\\n        \\\"\\\"\\\"\\n        return self._main_branch in self.branches\\n\\n    @property\\n    def branches(self) -> Set[str]:\\n        \\\"\\\"\\\"\\n        Return the set of branches that contain the commit.\\n\\n        :return: set(str) branches\\n        \\\"\\\"\\\"\\n        if self._branches is None:\\n            self._branches = self._get_branches()\\n\\n        return self._branches\\n\\n    def _get_branches(self):\\n        c_git = Git(str(self.project_path))\\n        branches = set()\\n        for branch in set(c_git.branch('--contains', self.hash).split('\\n')):\\n            branches.add(branch.strip().replace('* ', ''))\\n        return branches\\n\\n    # pylint disable=R0902\\n    def _from_change_to_modification_type(self, diff: Diff):\\n        if diff.new_file:\\n            return ModificationType.ADD\\n        if diff.deleted_file:\\n            return ModificationType.DELETE\\n        if diff.renamed_file:\\n            return ModificationType.RENAME\\n        if diff.a_blob and diff.b_blob and diff.a_blob != diff.b_blob:\\n            return ModificationType.MODIFY\\n\\n        return ModificationType.UNKNOWN\\n\\n    def __eq__(self, other):\\n        if not isinstance(other, Commit):\\n            return NotImplemented\\n        if self is other:\\n            return True\\n\\n        return self.__dict__ == other.__dict__\\n\\n    def __str__(self): # pragma: no cover\\n        return (\\n            'Hash: {}\\n'.format(self.hash) +\\n            'Author: {}\\n'.format(self.author.name) +\\n            'Author email: {}\\n'.format(self.author.email) +\\n            'Committer: {}\\n'.format(self.committer.name) +\\n            'Committer email: {}\\n'.format(self.committer.email) +\\n            'Author date: {}\\n'.format(\\n                self.author_date.strftime(\\\"%Y-%m-%d %H:%M:%S\\\")) +\\n            'Committer date: {}\\n'.format(\\n                self.committer_date.strftime(\\\"%Y-%m-%d %H:%M:%S\\\")) +\\n            'Message: {}\\n'.format(self.msg) +\\n            'Parent: {}\\n'.format(\\\"\\n\\\".join(map(str, self.parents))) +\\n            'Merge: {}\\n'.format(self.merge) +\\n            'Modifications: \\n{}'.format(\\n                \\\"\\n\\\".join(map(str, self.modifications))) +\\n            'Branches: \\n{}'.format(\\\"\\n\\\".join(map(str, self.branches))) +\\n            'In main branch: {}\\n'.format(self.in_main_branch)\\n        )\\n\\\"\\\"\\\"\\nTest which tests class Commit and dmm_unit_complexity. For the test use test-repos/dmm-test-repo. Assert the dmm_unit_complexity to be 1.0\\n\\\"\\\"\\\"\\ndef test_\\n\\nif __name__ == '__main__':\\n    from pydriller import RepositoryMining\\n    from pydriller.domain.commit import Commit\\n    from pydriller.metrics.process.dmm_unit_complexity import DMMUnitComplexity\\n    from pydriller.metrics.process.dmm_unit_complexity import DMMUnitComplexity\\n    from pydriller.metrics.process.dmm_unit_complexity import DMMUnitComplexity\\n    from pydriller.metrics.process.dmm_unit_complexity import DMMUnitComplexity\\n    from pydriller.metrics.process.dmm_unit_complexity import DMMUnitComplexity\\n    from pydriller.metrics.process.dmm_unit_complexity import DMMUnitComplexity\\n    from pydriller.metrics.process.dmm_unit_complexity import DMMUnitComplexity\\n    from pydriller.metrics.process.dmm_unit_complexity import DMMUnitComplexity\\n    from\"\n",
      "    },\n",
      "    {\n",
      "      \"finish_reason\": \"length\",\n",
      "      \"index\": 1,\n",
      "      \"logprobs\": null,\n",
      "      \"text\": \"\\n# Copyright 2018 Davide Spadini\\n#\\n# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n# you may not use this file except in compliance with the License.\\n# You may obtain a copy of the License at\\n#\\n#    http://www.apache.org/licenses/LICENSE-2.0\\n#\\n# Unless required by applicable law or agreed to in writing, software\\n# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n# See the License for the specific language governing permissions and\\n# limitations under the License.\\n\\n\\\"\\\"\\\"\\nThis module contains all the classes regarding a specific commit, such as\\nCommit, Modification,\\nModificationType and Method.\\n\\\"\\\"\\\"\\n\\nimport logging\\nfrom _datetime import datetime\\nfrom enum import Enum\\nfrom pathlib import Path\\nfrom typing import List, Set, Dict\\n\\nimport lizard\\nfrom git import Repo, Diff, Git, Commit as GitCommit\\n\\nfrom pydriller.domain.developer import Developer\\n\\nlogger = logging.getLogger(__name__)\\n\\nNULL_TREE = '4b825dc642cb6eb9a060e54bf8d69288fbee4904'\\n\\n\\nclass ModificationType(Enum):\\n    \\\"\\\"\\\"\\n    Type of Modification. Can be ADD, COPY, RENAME, DELETE, MODIFY or UNKNOWN.\\n    \\\"\\\"\\\"\\n\\n    ADD = 1\\n    COPY = 2\\n    RENAME = 3\\n    DELETE = 4\\n    MODIFY = 5\\n    UNKNOWN = 6\\n\\n\\nclass Method:  # pylint: disable=R0902\\n    \\\"\\\"\\\"\\n    This class represents a method in a class. Contains various information\\n    extracted through Lizard.\\n    \\\"\\\"\\\"\\n\\n    def __init__(self, func):\\n        \\\"\\\"\\\"\\n        Initialize a method object. This is calculated using Lizard: it parses\\n        the source code of all the modifications in a commit, extracting\\n        information of the methods contained in the file (if the file is a\\n        source code written in one of the supported programming languages).\\n        \\\"\\\"\\\"\\n\\n        self.name = func.name\\n        self.long_name = func.long_name\\n        self.filename = func.filename\\n        self.nloc = func.nloc\\n        self.complexity = func.cyclomatic_complexity\\n        self.token_count = func.token_count\\n        self.parameters = func.parameters\\n        self.start_line = func.start_line\\n        self.end_line = func.end_line\\n        self.fan_in = func.fan_in\\n        self.fan_out = func.fan_out\\n        self.general_fan_out = func.general_fan_out\\n        self.length = func.length\\n        self.top_nesting_level = func.top_nesting_level\\n\\n\\nclass Modification:  # pylint: disable=R0902\\n    \\\"\\\"\\\"\\n    This class contains information regarding a modified file in a commit.\\n    \\\"\\\"\\\"\\n\\n    def __init__(self, old_path: str, new_path: str,\\n                 change_type: ModificationType,\\n                 diff_and_sc: Dict[str, str]):\\n        \\\"\\\"\\\"\\n        Initialize a modification. A modification carries on information\\n        regarding the changed file. Normally, you shouldn't initialize a new\\n        one.\\n        \\\"\\\"\\\"\\n        self._old_path = Path(old_path) if old_path is not None else None\\n        self._new_path = Path(new_path) if new_path is not None else None\\n        self.change_type = change_type\\n        self.diff = diff_and_sc['diff']\\n        self.source_code = diff_and_sc['source_code']\\n        self.source_code_before = diff_and_sc['source_code_before']\\n\\n        self._nloc = None\\n        self._complexity = None\\n        self._token_count = None\\n        self._function_list = []\\n\\n    @property\\n    def added(self) -> int:\\n        \\\"\\\"\\\"\\n        Return the total number of added lines in the file.\\n\\n        :return: int lines_added\\n        \\\"\\\"\\\"\\n        added = 0\\n        for line in self.diff.replace('\\r', '').split(\\\"\\n\\\"):\\n            if line.startswith('+') and not line.startswith('+++'):\\n                added += 1\\n        return added\\n\\n    @property\\n    def removed(self):\\n        \\\"\\\"\\\"\\n        Return the total number of deleted lines in the file.\\n\\n        :return: int lines_deleted\\n        \\\"\\\"\\\"\\n        removed = 0\\n        for line in self.diff.replace('\\r', '').split(\\\"\\n\\\"):\\n            if line.startswith('-') and not line.startswith('---'):\\n                removed += 1\\n        return removed\\n\\n    @property\\n    def old_path(self):\\n        \\\"\\\"\\\"\\n        Old path of the file. Can be None if the file is added.\\n\\n        :return: str old_path\\n        \\\"\\\"\\\"\\n        if self._old_path:\\n            return str(self._old_path)\\n        return self._old_path\\n\\n    @property\\n    def new_path(self):\\n        \\\"\\\"\\\"\\n        New path of the file. Can be None if the file is deleted.\\n\\n        :return: str new_path\\n        \\\"\\\"\\\"\\n        if self._new_path:\\n            return str(self._new_path)\\n        return self._new_path\\n\\n    @property\\n    def filename(self) -> str:\\n        \\\"\\\"\\\"\\n        Return the filename. Given a path-like-string (e.g.\\n        \\\"/Users/dspadini/pydriller/myfile.py\\\") returns only the filename\\n        (e.g. \\\"myfile.py\\\")\\n\\n        :return: str filename\\n        \\\"\\\"\\\"\\n        if self._new_path is not None and str(self._new_path) != \\\"/dev/null\\\":\\n            path = self._new_path\\n        else:\\n            path = self._old_path\\n\\n        return path.name\\n\\n    @property\\n    def nloc(self) -> int:\\n        \\\"\\\"\\\"\\n        Calculate the LOC of the file.\\n\\n        :return: LOC of the file\\n        \\\"\\\"\\\"\\n        self._calculate_metrics()\\n        return self._nloc\\n\\n    @property\\n    def complexity(self) -> int:\\n        \\\"\\\"\\\"\\n        Calculate the Cyclomatic Complexity of the file.\\n\\n        :return: Cyclomatic Complexity of the file\\n        \\\"\\\"\\\"\\n        self._calculate_metrics()\\n        return self._complexity\\n\\n    @property\\n    def token_count(self) -> int:\\n        \\\"\\\"\\\"\\n        Calculate the token count of functions.\\n\\n        :return: token count\\n        \\\"\\\"\\\"\\n        self._calculate_metrics()\\n        return self._token_count\\n\\n    @property\\n    def methods(self) -> List[Method]:\\n        \\\"\\\"\\\"\\n        Return the list of methods in the file. Every method\\n        contains various information like complexity, loc, name,\\n        number of parameters, etc.\\n\\n        :return: list of methods\\n        \\\"\\\"\\\"\\n        self._calculate_metrics()\\n        return self._function_list\\n\\n    def _calculate_metrics(self):\\n        if self.source_code and self._nloc is None:\\n            l = lizard.analyze_file.analyze_source_code(self.filename,\\n                                                        self.source_code)\\n\\n            self._nloc = l.nloc\\n            self._complexity = l.CCN\\n            self._token_count = l.token_count\\n\\n            for func in l.function_list:\\n                self._function_list.append(Method(func))\\n\\n    def __eq__(self, other):\\n        if not isinstance(other, Modification):\\n            return NotImplemented\\n        if self is other:\\n            return True\\n        return self.__dict__ == other.__dict__\\n\\n    def __str__(self): # pragma: no cover\\n        return (\\n            'MODIFICATION\\n' +\\n            'Old Path: {}\\n'.format(self.old_path) +\\n            'New Path: {}\\n'.format(self.new_path) +\\n            'Type: {}\\n'.format(self.change_type.name) +\\n            'Diff: {}\\n'.format(self.diff) +\\n            'Source code before: {}\\n'.format(self.source_code_before) +\\n            'Source code: {}\\n'.format(self.source_code)\\n        )\\n\\n\\nclass Commit:\\n    \\\"\\\"\\\"\\n    Class representing a Commit. Contains all the important information such\\n    as hash, author, dates, and modified files.\\n    \\\"\\\"\\\"\\n\\n    def __init__(self, commit: GitCommit, project_path: Path,\\n                 main_branch: str) -> None:\\n        \\\"\\\"\\\"\\n        Create a commit object.\\n\\n        :param commit: GitPython Commit object\\n        :param project_path: path to the project (temporary folder in case\\n            of a remote repository)\\n        :param main_branch: main branch of the repo\\n        \\\"\\\"\\\"\\n        self._c_object = commit\\n        self._main_branch = main_branch\\n        self.project_path = project_path\\n\\n        self._modifications = None\\n        self._branches = None\\n\\n    @property\\n    def hash(self) -> str:\\n        \\\"\\\"\\\"\\n        Return the SHA of the commit.\\n\\n        :return: str hash\\n        \\\"\\\"\\\"\\n        return self._c_object.hexsha\\n\\n    @property\\n    def author(self) -> Developer:\\n        \\\"\\\"\\\"\\n        Return the author of the commit as a Developer object.\\n\\n        :return: author\\n        \\\"\\\"\\\"\\n        return Developer(self._c_object.author.name,\\n                         self._c_object.author.email)\\n\\n    @property\\n    def committer(self) -> Developer:\\n        \\\"\\\"\\\"\\n        Return the committer of the commit as a Developer object.\\n\\n        :return: committer\\n        \\\"\\\"\\\"\\n        return Developer(self._c_object.committer.name,\\n                         self._c_object.committer.email)\\n\\n    @property\\n    def project_name(self) -> str:\\n        \\\"\\\"\\\"\\n        Return the project name.\\n\\n        :return: project name\\n        \\\"\\\"\\\"\\n        return self.project_path.name\\n\\n    @property\\n    def author_date(self) -> datetime:\\n        \\\"\\\"\\\"\\n        Return the authored datetime.\\n\\n        :return: datetime author_datetime\\n        \\\"\\\"\\\"\\n        return self._c_object.authored_datetime\\n\\n    @property\\n    def committer_date(self) -> datetime:\\n        \\\"\\\"\\\"\\n        Return the committed datetime.\\n\\n        :return: datetime committer_datetime\\n        \\\"\\\"\\\"\\n        return self._c_object.committed_datetime\\n\\n    @property\\n    def author_timezone(self) -> int:\\n        \\\"\\\"\\\"\\n        Author timezone expressed in seconds from epoch.\\n\\n        :return: int timezone\\n        \\\"\\\"\\\"\\n        return self._c_object.author_tz_offset\\n\\n    @property\\n    def committer_timezone(self) -> int:\\n        \\\"\\\"\\\"\\n        Author timezone expressed in seconds from epoch.\\n\\n        :return: int timezone\\n        \\\"\\\"\\\"\\n        return self._c_object.committer_tz_offset\\n\\n    @property\\n    def msg(self) -> str:\\n        \\\"\\\"\\\"\\n        Return commit message.\\n\\n        :return: str commit_message\\n        \\\"\\\"\\\"\\n        return self._c_object.message.strip()\\n\\n    @property\\n    def parents(self) -> List[str]:\\n        \\\"\\\"\\\"\\n        Return the list of parents SHAs.\\n\\n        :return: List[str] parents\\n        \\\"\\\"\\\"\\n        parents = []\\n        for p in self._c_object.parents:\\n            parents.append(p.hexsha)\\n        return parents\\n\\n    @property\\n    def merge(self) -> bool:\\n        \\\"\\\"\\\"\\n        Return True if the commit is a merge, False otherwise.\\n\\n        :return: bool merge\\n        \\\"\\\"\\\"\\n        return len(self._c_object.parents) > 1\\n\\n    @property\\n    def modifications(self) -> List[Modification]:\\n        \\\"\\\"\\\"\\n        Return a list of modified files.\\n\\n        :return: List[Modification] modifications\\n        \\\"\\\"\\\"\\n        if self._modifications is None:\\n            self._modifications = self._get_modifications()\\n\\n        return self._modifications\\n\\n    def _get_modifications(self):\\n        repo = Repo(str(self.project_path))\\n        commit = self._c_object\\n\\n        if len(self.parents) == 1:\\n            # the commit has a parent\\n            diff_index = self._c_object.parents[0].diff(commit,\\n                                                        create_patch=True)\\n        elif len(self.parents) > 1:\\n            # if it's a merge commit, the modified files of the commit are the\\n            # conflicts. This because if the file is not in conflict,\\n            # pydriller will visit the modification in one of the previous\\n            # commits. However, parsing the output of a combined diff (that\\n            # returns the list of conflicts) is challenging: so, right now,\\n            # I will return an empty array, in the meanwhile I will try to\\n            # find a way to parse the output.\\n            # c_git = Git(str(self.project_path))\\n            # d = c_git.diff_tree(\\\"--cc\\\", commit.hexsha, '-r', '--abbrev=40',\\n            #                     '--full-index', '-M', '-p', '--no-color')\\n            diff_index = []\\n        else:\\n            # this is the first commit of the repo. Comparing it with git\\n            # NULL TREE\\n            parent = repo.tree(NULL_TREE)\\n            diff_index = parent.diff(commit.tree, create_patch=True)\\n\\n        return self._parse_diff(diff_index)\\n\\n    def _parse_diff(self, diff_index) -> List[Modification]:\\n        modifications_list = []\\n        for diff in diff_index:\\n            old_path = diff.a_path\\n            new_path = diff.b_path\\n            change_type = self._from_change_to_modification_type(diff)\\n\\n            diff_and_sc = {\\n                'diff': self._get_decoded_str(diff.diff),\\n                'source_code_before': self._get_decoded_sc_str(\\n                    diff.a_blob),\\n                'source_code': self._get_decoded_sc_str(\\n                    diff.b_blob)\\n            }\\n\\n            modifications_list.append(Modification(old_path, new_path,\\n                                                   change_type, diff_and_sc))\\n\\n        return modifications_list\\n\\n    def _get_decoded_str(self, diff):\\n        try:\\n            return diff.decode('utf-8', 'ignore')\\n        except (UnicodeDecodeError, AttributeError, ValueError):\\n            logger.debug('Could not load the diff of a '\\n                         'file in commit %s', self._c_object.hexsha)\\n            return None\\n\\n    def _get_decoded_sc_str(self, diff):\\n        try:\\n            return diff.data_stream.read().decode('utf-8', 'ignore')\\n        except (UnicodeDecodeError, AttributeError, ValueError):\\n            logger.debug('Could not load source code of a '\\n                         'file in commit %s', self._c_object.hexsha)\\n            return None\\n\\n    @property\\n    def in_main_branch(self) -> bool:\\n        \\\"\\\"\\\"\\n        Return True if the commit is in the main branch, False otherwise.\\n\\n        :return: bool in_main_branch\\n        \\\"\\\"\\\"\\n        return self._main_branch in self.branches\\n\\n    @property\\n    def branches(self) -> Set[str]:\\n        \\\"\\\"\\\"\\n        Return the set of branches that contain the commit.\\n\\n        :return: set(str) branches\\n        \\\"\\\"\\\"\\n        if self._branches is None:\\n            self._branches = self._get_branches()\\n\\n        return self._branches\\n\\n    def _get_branches(self):\\n        c_git = Git(str(self.project_path))\\n        branches = set()\\n        for branch in set(c_git.branch('--contains', self.hash).split('\\n')):\\n            branches.add(branch.strip().replace('* ', ''))\\n        return branches\\n\\n    # pylint disable=R0902\\n    def _from_change_to_modification_type(self, diff: Diff):\\n        if diff.new_file:\\n            return ModificationType.ADD\\n        if diff.deleted_file:\\n            return ModificationType.DELETE\\n        if diff.renamed_file:\\n            return ModificationType.RENAME\\n        if diff.a_blob and diff.b_blob and diff.a_blob != diff.b_blob:\\n            return ModificationType.MODIFY\\n\\n        return ModificationType.UNKNOWN\\n\\n    def __eq__(self, other):\\n        if not isinstance(other, Commit):\\n            return NotImplemented\\n        if self is other:\\n            return True\\n\\n        return self.__dict__ == other.__dict__\\n\\n    def __str__(self): # pragma: no cover\\n        return (\\n            'Hash: {}\\n'.format(self.hash) +\\n            'Author: {}\\n'.format(self.author.name) +\\n            'Author email: {}\\n'.format(self.author.email) +\\n            'Committer: {}\\n'.format(self.committer.name) +\\n            'Committer email: {}\\n'.format(self.committer.email) +\\n            'Author date: {}\\n'.format(\\n                self.author_date.strftime(\\\"%Y-%m-%d %H:%M:%S\\\")) +\\n            'Committer date: {}\\n'.format(\\n                self.committer_date.strftime(\\\"%Y-%m-%d %H:%M:%S\\\")) +\\n            'Message: {}\\n'.format(self.msg) +\\n            'Parent: {}\\n'.format(\\\"\\n\\\".join(map(str, self.parents))) +\\n            'Merge: {}\\n'.format(self.merge) +\\n            'Modifications: \\n{}'.format(\\n                \\\"\\n\\\".join(map(str, self.modifications))) +\\n            'Branches: \\n{}'.format(\\\"\\n\\\".join(map(str, self.branches))) +\\n            'In main branch: {}\\n'.format(self.in_main_branch)\\n        )\\n\\\"\\\"\\\"\\nTest which tests class Commit and dmm_unit_complexity. For the test use test-repos/dmm-test-repo. Assert the dmm_unit_complexity to be 1.0\\n\\\"\\\"\\\"\\ndef test_\\n\\nif __name__ == '__main__':\\n    from pydriller import RepositoryMining\\n    from pydriller.domain.commit import Commit\\n    from pydriller.metrics.process.dmm_unit_complexity import DMMUnitComplexity\\n    from pydriller.metrics.process.dmm_unit_complexity import DMMUnitComplexity\\n    from pydriller.metrics.process.dmm_unit_complexity import DMMUnitComplexity\\n    from pydriller.metrics.process.dmm_unit_complexity import DMMUnitComplexity\\n    from pydriller.metrics.process.dmm_unit_complexity import DMMUnitComplexity\\n    from pydriller.metrics.process.dmm_unit_complexity import DMMUnitComplexity\\n    from pydriller.metrics.process.dmm_unit_complexity import DMMUnitComplexity\\n    from pydriller.metrics.process.dmm_unit_complexity import DMMUnitComplexity\\n    from\"\n",
      "    },\n",
      "    {\n",
      "      \"finish_reason\": \"length\",\n",
      "      \"index\": 2,\n",
      "      \"logprobs\": null,\n",
      "      \"text\": \"\\n# Copyright 2018 Davide Spadini\\n#\\n# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n# you may not use this file except in compliance with the License.\\n# You may obtain a copy of the License at\\n#\\n#    http://www.apache.org/licenses/LICENSE-2.0\\n#\\n# Unless required by applicable law or agreed to in writing, software\\n# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n# See the License for the specific language governing permissions and\\n# limitations under the License.\\n\\n\\\"\\\"\\\"\\nThis module contains all the classes regarding a specific commit, such as\\nCommit, Modification,\\nModificationType and Method.\\n\\\"\\\"\\\"\\n\\nimport logging\\nfrom _datetime import datetime\\nfrom enum import Enum\\nfrom pathlib import Path\\nfrom typing import List, Set, Dict\\n\\nimport lizard\\nfrom git import Repo, Diff, Git, Commit as GitCommit\\n\\nfrom pydriller.domain.developer import Developer\\n\\nlogger = logging.getLogger(__name__)\\n\\nNULL_TREE = '4b825dc642cb6eb9a060e54bf8d69288fbee4904'\\n\\n\\nclass ModificationType(Enum):\\n    \\\"\\\"\\\"\\n    Type of Modification. Can be ADD, COPY, RENAME, DELETE, MODIFY or UNKNOWN.\\n    \\\"\\\"\\\"\\n\\n    ADD = 1\\n    COPY = 2\\n    RENAME = 3\\n    DELETE = 4\\n    MODIFY = 5\\n    UNKNOWN = 6\\n\\n\\nclass Method:  # pylint: disable=R0902\\n    \\\"\\\"\\\"\\n    This class represents a method in a class. Contains various information\\n    extracted through Lizard.\\n    \\\"\\\"\\\"\\n\\n    def __init__(self, func):\\n        \\\"\\\"\\\"\\n        Initialize a method object. This is calculated using Lizard: it parses\\n        the source code of all the modifications in a commit, extracting\\n        information of the methods contained in the file (if the file is a\\n        source code written in one of the supported programming languages).\\n        \\\"\\\"\\\"\\n\\n        self.name = func.name\\n        self.long_name = func.long_name\\n        self.filename = func.filename\\n        self.nloc = func.nloc\\n        self.complexity = func.cyclomatic_complexity\\n        self.token_count = func.token_count\\n        self.parameters = func.parameters\\n        self.start_line = func.start_line\\n        self.end_line = func.end_line\\n        self.fan_in = func.fan_in\\n        self.fan_out = func.fan_out\\n        self.general_fan_out = func.general_fan_out\\n        self.length = func.length\\n        self.top_nesting_level = func.top_nesting_level\\n\\n\\nclass Modification:  # pylint: disable=R0902\\n    \\\"\\\"\\\"\\n    This class contains information regarding a modified file in a commit.\\n    \\\"\\\"\\\"\\n\\n    def __init__(self, old_path: str, new_path: str,\\n                 change_type: ModificationType,\\n                 diff_and_sc: Dict[str, str]):\\n        \\\"\\\"\\\"\\n        Initialize a modification. A modification carries on information\\n        regarding the changed file. Normally, you shouldn't initialize a new\\n        one.\\n        \\\"\\\"\\\"\\n        self._old_path = Path(old_path) if old_path is not None else None\\n        self._new_path = Path(new_path) if new_path is not None else None\\n        self.change_type = change_type\\n        self.diff = diff_and_sc['diff']\\n        self.source_code = diff_and_sc['source_code']\\n        self.source_code_before = diff_and_sc['source_code_before']\\n\\n        self._nloc = None\\n        self._complexity = None\\n        self._token_count = None\\n        self._function_list = []\\n\\n    @property\\n    def added(self) -> int:\\n        \\\"\\\"\\\"\\n        Return the total number of added lines in the file.\\n\\n        :return: int lines_added\\n        \\\"\\\"\\\"\\n        added = 0\\n        for line in self.diff.replace('\\r', '').split(\\\"\\n\\\"):\\n            if line.startswith('+') and not line.startswith('+++'):\\n                added += 1\\n        return added\\n\\n    @property\\n    def removed(self):\\n        \\\"\\\"\\\"\\n        Return the total number of deleted lines in the file.\\n\\n        :return: int lines_deleted\\n        \\\"\\\"\\\"\\n        removed = 0\\n        for line in self.diff.replace('\\r', '').split(\\\"\\n\\\"):\\n            if line.startswith('-') and not line.startswith('---'):\\n                removed += 1\\n        return removed\\n\\n    @property\\n    def old_path(self):\\n        \\\"\\\"\\\"\\n        Old path of the file. Can be None if the file is added.\\n\\n        :return: str old_path\\n        \\\"\\\"\\\"\\n        if self._old_path:\\n            return str(self._old_path)\\n        return self._old_path\\n\\n    @property\\n    def new_path(self):\\n        \\\"\\\"\\\"\\n        New path of the file. Can be None if the file is deleted.\\n\\n        :return: str new_path\\n        \\\"\\\"\\\"\\n        if self._new_path:\\n            return str(self._new_path)\\n        return self._new_path\\n\\n    @property\\n    def filename(self) -> str:\\n        \\\"\\\"\\\"\\n        Return the filename. Given a path-like-string (e.g.\\n        \\\"/Users/dspadini/pydriller/myfile.py\\\") returns only the filename\\n        (e.g. \\\"myfile.py\\\")\\n\\n        :return: str filename\\n        \\\"\\\"\\\"\\n        if self._new_path is not None and str(self._new_path) != \\\"/dev/null\\\":\\n            path = self._new_path\\n        else:\\n            path = self._old_path\\n\\n        return path.name\\n\\n    @property\\n    def nloc(self) -> int:\\n        \\\"\\\"\\\"\\n        Calculate the LOC of the file.\\n\\n        :return: LOC of the file\\n        \\\"\\\"\\\"\\n        self._calculate_metrics()\\n        return self._nloc\\n\\n    @property\\n    def complexity(self) -> int:\\n        \\\"\\\"\\\"\\n        Calculate the Cyclomatic Complexity of the file.\\n\\n        :return: Cyclomatic Complexity of the file\\n        \\\"\\\"\\\"\\n        self._calculate_metrics()\\n        return self._complexity\\n\\n    @property\\n    def token_count(self) -> int:\\n        \\\"\\\"\\\"\\n        Calculate the token count of functions.\\n\\n        :return: token count\\n        \\\"\\\"\\\"\\n        self._calculate_metrics()\\n        return self._token_count\\n\\n    @property\\n    def methods(self) -> List[Method]:\\n        \\\"\\\"\\\"\\n        Return the list of methods in the file. Every method\\n        contains various information like complexity, loc, name,\\n        number of parameters, etc.\\n\\n        :return: list of methods\\n        \\\"\\\"\\\"\\n        self._calculate_metrics()\\n        return self._function_list\\n\\n    def _calculate_metrics(self):\\n        if self.source_code and self._nloc is None:\\n            l = lizard.analyze_file.analyze_source_code(self.filename,\\n                                                        self.source_code)\\n\\n            self._nloc = l.nloc\\n            self._complexity = l.CCN\\n            self._token_count = l.token_count\\n\\n            for func in l.function_list:\\n                self._function_list.append(Method(func))\\n\\n    def __eq__(self, other):\\n        if not isinstance(other, Modification):\\n            return NotImplemented\\n        if self is other:\\n            return True\\n        return self.__dict__ == other.__dict__\\n\\n    def __str__(self): # pragma: no cover\\n        return (\\n            'MODIFICATION\\n' +\\n            'Old Path: {}\\n'.format(self.old_path) +\\n            'New Path: {}\\n'.format(self.new_path) +\\n            'Type: {}\\n'.format(self.change_type.name) +\\n            'Diff: {}\\n'.format(self.diff) +\\n            'Source code before: {}\\n'.format(self.source_code_before) +\\n            'Source code: {}\\n'.format(self.source_code)\\n        )\\n\\n\\nclass Commit:\\n    \\\"\\\"\\\"\\n    Class representing a Commit. Contains all the important information such\\n    as hash, author, dates, and modified files.\\n    \\\"\\\"\\\"\\n\\n    def __init__(self, commit: GitCommit, project_path: Path,\\n                 main_branch: str) -> None:\\n        \\\"\\\"\\\"\\n        Create a commit object.\\n\\n        :param commit: GitPython Commit object\\n        :param project_path: path to the project (temporary folder in case\\n            of a remote repository)\\n        :param main_branch: main branch of the repo\\n        \\\"\\\"\\\"\\n        self._c_object = commit\\n        self._main_branch = main_branch\\n        self.project_path = project_path\\n\\n        self._modifications = None\\n        self._branches = None\\n\\n    @property\\n    def hash(self) -> str:\\n        \\\"\\\"\\\"\\n        Return the SHA of the commit.\\n\\n        :return: str hash\\n        \\\"\\\"\\\"\\n        return self._c_object.hexsha\\n\\n    @property\\n    def author(self) -> Developer:\\n        \\\"\\\"\\\"\\n        Return the author of the commit as a Developer object.\\n\\n        :return: author\\n        \\\"\\\"\\\"\\n        return Developer(self._c_object.author.name,\\n                         self._c_object.author.email)\\n\\n    @property\\n    def committer(self) -> Developer:\\n        \\\"\\\"\\\"\\n        Return the committer of the commit as a Developer object.\\n\\n        :return: committer\\n        \\\"\\\"\\\"\\n        return Developer(self._c_object.committer.name,\\n                         self._c_object.committer.email)\\n\\n    @property\\n    def project_name(self) -> str:\\n        \\\"\\\"\\\"\\n        Return the project name.\\n\\n        :return: project name\\n        \\\"\\\"\\\"\\n        return self.project_path.name\\n\\n    @property\\n    def author_date(self) -> datetime:\\n        \\\"\\\"\\\"\\n        Return the authored datetime.\\n\\n        :return: datetime author_datetime\\n        \\\"\\\"\\\"\\n        return self._c_object.authored_datetime\\n\\n    @property\\n    def committer_date(self) -> datetime:\\n        \\\"\\\"\\\"\\n        Return the committed datetime.\\n\\n        :return: datetime committer_datetime\\n        \\\"\\\"\\\"\\n        return self._c_object.committed_datetime\\n\\n    @property\\n    def author_timezone(self) -> int:\\n        \\\"\\\"\\\"\\n        Author timezone expressed in seconds from epoch.\\n\\n        :return: int timezone\\n        \\\"\\\"\\\"\\n        return self._c_object.author_tz_offset\\n\\n    @property\\n    def committer_timezone(self) -> int:\\n        \\\"\\\"\\\"\\n        Author timezone expressed in seconds from epoch.\\n\\n        :return: int timezone\\n        \\\"\\\"\\\"\\n        return self._c_object.committer_tz_offset\\n\\n    @property\\n    def msg(self) -> str:\\n        \\\"\\\"\\\"\\n        Return commit message.\\n\\n        :return: str commit_message\\n        \\\"\\\"\\\"\\n        return self._c_object.message.strip()\\n\\n    @property\\n    def parents(self) -> List[str]:\\n        \\\"\\\"\\\"\\n        Return the list of parents SHAs.\\n\\n        :return: List[str] parents\\n        \\\"\\\"\\\"\\n        parents = []\\n        for p in self._c_object.parents:\\n            parents.append(p.hexsha)\\n        return parents\\n\\n    @property\\n    def merge(self) -> bool:\\n        \\\"\\\"\\\"\\n        Return True if the commit is a merge, False otherwise.\\n\\n        :return: bool merge\\n        \\\"\\\"\\\"\\n        return len(self._c_object.parents) > 1\\n\\n    @property\\n    def modifications(self) -> List[Modification]:\\n        \\\"\\\"\\\"\\n        Return a list of modified files.\\n\\n        :return: List[Modification] modifications\\n        \\\"\\\"\\\"\\n        if self._modifications is None:\\n            self._modifications = self._get_modifications()\\n\\n        return self._modifications\\n\\n    def _get_modifications(self):\\n        repo = Repo(str(self.project_path))\\n        commit = self._c_object\\n\\n        if len(self.parents) == 1:\\n            # the commit has a parent\\n            diff_index = self._c_object.parents[0].diff(commit,\\n                                                        create_patch=True)\\n        elif len(self.parents) > 1:\\n            # if it's a merge commit, the modified files of the commit are the\\n            # conflicts. This because if the file is not in conflict,\\n            # pydriller will visit the modification in one of the previous\\n            # commits. However, parsing the output of a combined diff (that\\n            # returns the list of conflicts) is challenging: so, right now,\\n            # I will return an empty array, in the meanwhile I will try to\\n            # find a way to parse the output.\\n            # c_git = Git(str(self.project_path))\\n            # d = c_git.diff_tree(\\\"--cc\\\", commit.hexsha, '-r', '--abbrev=40',\\n            #                     '--full-index', '-M', '-p', '--no-color')\\n            diff_index = []\\n        else:\\n            # this is the first commit of the repo. Comparing it with git\\n            # NULL TREE\\n            parent = repo.tree(NULL_TREE)\\n            diff_index = parent.diff(commit.tree, create_patch=True)\\n\\n        return self._parse_diff(diff_index)\\n\\n    def _parse_diff(self, diff_index) -> List[Modification]:\\n        modifications_list = []\\n        for diff in diff_index:\\n            old_path = diff.a_path\\n            new_path = diff.b_path\\n            change_type = self._from_change_to_modification_type(diff)\\n\\n            diff_and_sc = {\\n                'diff': self._get_decoded_str(diff.diff),\\n                'source_code_before': self._get_decoded_sc_str(\\n                    diff.a_blob),\\n                'source_code': self._get_decoded_sc_str(\\n                    diff.b_blob)\\n            }\\n\\n            modifications_list.append(Modification(old_path, new_path,\\n                                                   change_type, diff_and_sc))\\n\\n        return modifications_list\\n\\n    def _get_decoded_str(self, diff):\\n        try:\\n            return diff.decode('utf-8', 'ignore')\\n        except (UnicodeDecodeError, AttributeError, ValueError):\\n            logger.debug('Could not load the diff of a '\\n                         'file in commit %s', self._c_object.hexsha)\\n            return None\\n\\n    def _get_decoded_sc_str(self, diff):\\n        try:\\n            return diff.data_stream.read().decode('utf-8', 'ignore')\\n        except (UnicodeDecodeError, AttributeError, ValueError):\\n            logger.debug('Could not load source code of a '\\n                         'file in commit %s', self._c_object.hexsha)\\n            return None\\n\\n    @property\\n    def in_main_branch(self) -> bool:\\n        \\\"\\\"\\\"\\n        Return True if the commit is in the main branch, False otherwise.\\n\\n        :return: bool in_main_branch\\n        \\\"\\\"\\\"\\n        return self._main_branch in self.branches\\n\\n    @property\\n    def branches(self) -> Set[str]:\\n        \\\"\\\"\\\"\\n        Return the set of branches that contain the commit.\\n\\n        :return: set(str) branches\\n        \\\"\\\"\\\"\\n        if self._branches is None:\\n            self._branches = self._get_branches()\\n\\n        return self._branches\\n\\n    def _get_branches(self):\\n        c_git = Git(str(self.project_path))\\n        branches = set()\\n        for branch in set(c_git.branch('--contains', self.hash).split('\\n')):\\n            branches.add(branch.strip().replace('* ', ''))\\n        return branches\\n\\n    # pylint disable=R0902\\n    def _from_change_to_modification_type(self, diff: Diff):\\n        if diff.new_file:\\n            return ModificationType.ADD\\n        if diff.deleted_file:\\n            return ModificationType.DELETE\\n        if diff.renamed_file:\\n            return ModificationType.RENAME\\n        if diff.a_blob and diff.b_blob and diff.a_blob != diff.b_blob:\\n            return ModificationType.MODIFY\\n\\n        return ModificationType.UNKNOWN\\n\\n    def __eq__(self, other):\\n        if not isinstance(other, Commit):\\n            return NotImplemented\\n        if self is other:\\n            return True\\n\\n        return self.__dict__ == other.__dict__\\n\\n    def __str__(self): # pragma: no cover\\n        return (\\n            'Hash: {}\\n'.format(self.hash) +\\n            'Author: {}\\n'.format(self.author.name) +\\n            'Author email: {}\\n'.format(self.author.email) +\\n            'Committer: {}\\n'.format(self.committer.name) +\\n            'Committer email: {}\\n'.format(self.committer.email) +\\n            'Author date: {}\\n'.format(\\n                self.author_date.strftime(\\\"%Y-%m-%d %H:%M:%S\\\")) +\\n            'Committer date: {}\\n'.format(\\n                self.committer_date.strftime(\\\"%Y-%m-%d %H:%M:%S\\\")) +\\n            'Message: {}\\n'.format(self.msg) +\\n            'Parent: {}\\n'.format(\\\"\\n\\\".join(map(str, self.parents))) +\\n            'Merge: {}\\n'.format(self.merge) +\\n            'Modifications: \\n{}'.format(\\n                \\\"\\n\\\".join(map(str, self.modifications))) +\\n            'Branches: \\n{}'.format(\\\"\\n\\\".join(map(str, self.branches))) +\\n            'In main branch: {}\\n'.format(self.in_main_branch)\\n        )\\n\\\"\\\"\\\"\\nTest which tests class Commit and dmm_unit_complexity. For the test use test-repos/dmm-test-repo. Assert the dmm_unit_complexity to be 1.0\\n\\\"\\\"\\\"\\ndef test_\\n\\nif __name__ == '__main__':\\n    from pydriller import RepositoryMining\\n    from pydriller.domain.commit import Commit\\n    from pydriller.metrics.process.dmm_unit_complexity import DMMUnitComplexity\\n    from pydriller.metrics.process.dmm_unit_complexity import DMMUnitComplexity\\n    from pydriller.metrics.process.dmm_unit_complexity import DMMUnitComplexity\\n    from pydriller.metrics.process.dmm_unit_complexity import DMMUnitComplexity\\n    from pydriller.metrics.process.dmm_unit_complexity import DMMUnitComplexity\\n    from pydriller.metrics.process.dmm_unit_complexity import DMMUnitComplexity\\n    from pydriller.metrics.process.dmm_unit_complexity import DMMUnitComplexity\\n    from pydriller.metrics.process.dmm_unit_complexity import DMMUnitComplexity\\n    from\"\n",
      "    },\n",
      "    {\n",
      "      \"finish_reason\": \"length\",\n",
      "      \"index\": 3,\n",
      "      \"logprobs\": null,\n",
      "      \"text\": \"\\n# Copyright 2018 Davide Spadini\\n#\\n# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n# you may not use this file except in compliance with the License.\\n# You may obtain a copy of the License at\\n#\\n#    http://www.apache.org/licenses/LICENSE-2.0\\n#\\n# Unless required by applicable law or agreed to in writing, software\\n# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n# See the License for the specific language governing permissions and\\n# limitations under the License.\\n\\n\\\"\\\"\\\"\\nThis module contains all the classes regarding a specific commit, such as\\nCommit, Modification,\\nModificationType and Method.\\n\\\"\\\"\\\"\\n\\nimport logging\\nfrom _datetime import datetime\\nfrom enum import Enum\\nfrom pathlib import Path\\nfrom typing import List, Set, Dict\\n\\nimport lizard\\nfrom git import Repo, Diff, Git, Commit as GitCommit\\n\\nfrom pydriller.domain.developer import Developer\\n\\nlogger = logging.getLogger(__name__)\\n\\nNULL_TREE = '4b825dc642cb6eb9a060e54bf8d69288fbee4904'\\n\\n\\nclass ModificationType(Enum):\\n    \\\"\\\"\\\"\\n    Type of Modification. Can be ADD, COPY, RENAME, DELETE, MODIFY or UNKNOWN.\\n    \\\"\\\"\\\"\\n\\n    ADD = 1\\n    COPY = 2\\n    RENAME = 3\\n    DELETE = 4\\n    MODIFY = 5\\n    UNKNOWN = 6\\n\\n\\nclass Method:  # pylint: disable=R0902\\n    \\\"\\\"\\\"\\n    This class represents a method in a class. Contains various information\\n    extracted through Lizard.\\n    \\\"\\\"\\\"\\n\\n    def __init__(self, func):\\n        \\\"\\\"\\\"\\n        Initialize a method object. This is calculated using Lizard: it parses\\n        the source code of all the modifications in a commit, extracting\\n        information of the methods contained in the file (if the file is a\\n        source code written in one of the supported programming languages).\\n        \\\"\\\"\\\"\\n\\n        self.name = func.name\\n        self.long_name = func.long_name\\n        self.filename = func.filename\\n        self.nloc = func.nloc\\n        self.complexity = func.cyclomatic_complexity\\n        self.token_count = func.token_count\\n        self.parameters = func.parameters\\n        self.start_line = func.start_line\\n        self.end_line = func.end_line\\n        self.fan_in = func.fan_in\\n        self.fan_out = func.fan_out\\n        self.general_fan_out = func.general_fan_out\\n        self.length = func.length\\n        self.top_nesting_level = func.top_nesting_level\\n\\n\\nclass Modification:  # pylint: disable=R0902\\n    \\\"\\\"\\\"\\n    This class contains information regarding a modified file in a commit.\\n    \\\"\\\"\\\"\\n\\n    def __init__(self, old_path: str, new_path: str,\\n                 change_type: ModificationType,\\n                 diff_and_sc: Dict[str, str]):\\n        \\\"\\\"\\\"\\n        Initialize a modification. A modification carries on information\\n        regarding the changed file. Normally, you shouldn't initialize a new\\n        one.\\n        \\\"\\\"\\\"\\n        self._old_path = Path(old_path) if old_path is not None else None\\n        self._new_path = Path(new_path) if new_path is not None else None\\n        self.change_type = change_type\\n        self.diff = diff_and_sc['diff']\\n        self.source_code = diff_and_sc['source_code']\\n        self.source_code_before = diff_and_sc['source_code_before']\\n\\n        self._nloc = None\\n        self._complexity = None\\n        self._token_count = None\\n        self._function_list = []\\n\\n    @property\\n    def added(self) -> int:\\n        \\\"\\\"\\\"\\n        Return the total number of added lines in the file.\\n\\n        :return: int lines_added\\n        \\\"\\\"\\\"\\n        added = 0\\n        for line in self.diff.replace('\\r', '').split(\\\"\\n\\\"):\\n            if line.startswith('+') and not line.startswith('+++'):\\n                added += 1\\n        return added\\n\\n    @property\\n    def removed(self):\\n        \\\"\\\"\\\"\\n        Return the total number of deleted lines in the file.\\n\\n        :return: int lines_deleted\\n        \\\"\\\"\\\"\\n        removed = 0\\n        for line in self.diff.replace('\\r', '').split(\\\"\\n\\\"):\\n            if line.startswith('-') and not line.startswith('---'):\\n                removed += 1\\n        return removed\\n\\n    @property\\n    def old_path(self):\\n        \\\"\\\"\\\"\\n        Old path of the file. Can be None if the file is added.\\n\\n        :return: str old_path\\n        \\\"\\\"\\\"\\n        if self._old_path:\\n            return str(self._old_path)\\n        return self._old_path\\n\\n    @property\\n    def new_path(self):\\n        \\\"\\\"\\\"\\n        New path of the file. Can be None if the file is deleted.\\n\\n        :return: str new_path\\n        \\\"\\\"\\\"\\n        if self._new_path:\\n            return str(self._new_path)\\n        return self._new_path\\n\\n    @property\\n    def filename(self) -> str:\\n        \\\"\\\"\\\"\\n        Return the filename. Given a path-like-string (e.g.\\n        \\\"/Users/dspadini/pydriller/myfile.py\\\") returns only the filename\\n        (e.g. \\\"myfile.py\\\")\\n\\n        :return: str filename\\n        \\\"\\\"\\\"\\n        if self._new_path is not None and str(self._new_path) != \\\"/dev/null\\\":\\n            path = self._new_path\\n        else:\\n            path = self._old_path\\n\\n        return path.name\\n\\n    @property\\n    def nloc(self) -> int:\\n        \\\"\\\"\\\"\\n        Calculate the LOC of the file.\\n\\n        :return: LOC of the file\\n        \\\"\\\"\\\"\\n        self._calculate_metrics()\\n        return self._nloc\\n\\n    @property\\n    def complexity(self) -> int:\\n        \\\"\\\"\\\"\\n        Calculate the Cyclomatic Complexity of the file.\\n\\n        :return: Cyclomatic Complexity of the file\\n        \\\"\\\"\\\"\\n        self._calculate_metrics()\\n        return self._complexity\\n\\n    @property\\n    def token_count(self) -> int:\\n        \\\"\\\"\\\"\\n        Calculate the token count of functions.\\n\\n        :return: token count\\n        \\\"\\\"\\\"\\n        self._calculate_metrics()\\n        return self._token_count\\n\\n    @property\\n    def methods(self) -> List[Method]:\\n        \\\"\\\"\\\"\\n        Return the list of methods in the file. Every method\\n        contains various information like complexity, loc, name,\\n        number of parameters, etc.\\n\\n        :return: list of methods\\n        \\\"\\\"\\\"\\n        self._calculate_metrics()\\n        return self._function_list\\n\\n    def _calculate_metrics(self):\\n        if self.source_code and self._nloc is None:\\n            l = lizard.analyze_file.analyze_source_code(self.filename,\\n                                                        self.source_code)\\n\\n            self._nloc = l.nloc\\n            self._complexity = l.CCN\\n            self._token_count = l.token_count\\n\\n            for func in l.function_list:\\n                self._function_list.append(Method(func))\\n\\n    def __eq__(self, other):\\n        if not isinstance(other, Modification):\\n            return NotImplemented\\n        if self is other:\\n            return True\\n        return self.__dict__ == other.__dict__\\n\\n    def __str__(self): # pragma: no cover\\n        return (\\n            'MODIFICATION\\n' +\\n            'Old Path: {}\\n'.format(self.old_path) +\\n            'New Path: {}\\n'.format(self.new_path) +\\n            'Type: {}\\n'.format(self.change_type.name) +\\n            'Diff: {}\\n'.format(self.diff) +\\n            'Source code before: {}\\n'.format(self.source_code_before) +\\n            'Source code: {}\\n'.format(self.source_code)\\n        )\\n\\n\\nclass Commit:\\n    \\\"\\\"\\\"\\n    Class representing a Commit. Contains all the important information such\\n    as hash, author, dates, and modified files.\\n    \\\"\\\"\\\"\\n\\n    def __init__(self, commit: GitCommit, project_path: Path,\\n                 main_branch: str) -> None:\\n        \\\"\\\"\\\"\\n        Create a commit object.\\n\\n        :param commit: GitPython Commit object\\n        :param project_path: path to the project (temporary folder in case\\n            of a remote repository)\\n        :param main_branch: main branch of the repo\\n        \\\"\\\"\\\"\\n        self._c_object = commit\\n        self._main_branch = main_branch\\n        self.project_path = project_path\\n\\n        self._modifications = None\\n        self._branches = None\\n\\n    @property\\n    def hash(self) -> str:\\n        \\\"\\\"\\\"\\n        Return the SHA of the commit.\\n\\n        :return: str hash\\n        \\\"\\\"\\\"\\n        return self._c_object.hexsha\\n\\n    @property\\n    def author(self) -> Developer:\\n        \\\"\\\"\\\"\\n        Return the author of the commit as a Developer object.\\n\\n        :return: author\\n        \\\"\\\"\\\"\\n        return Developer(self._c_object.author.name,\\n                         self._c_object.author.email)\\n\\n    @property\\n    def committer(self) -> Developer:\\n        \\\"\\\"\\\"\\n        Return the committer of the commit as a Developer object.\\n\\n        :return: committer\\n        \\\"\\\"\\\"\\n        return Developer(self._c_object.committer.name,\\n                         self._c_object.committer.email)\\n\\n    @property\\n    def project_name(self) -> str:\\n        \\\"\\\"\\\"\\n        Return the project name.\\n\\n        :return: project name\\n        \\\"\\\"\\\"\\n        return self.project_path.name\\n\\n    @property\\n    def author_date(self) -> datetime:\\n        \\\"\\\"\\\"\\n        Return the authored datetime.\\n\\n        :return: datetime author_datetime\\n        \\\"\\\"\\\"\\n        return self._c_object.authored_datetime\\n\\n    @property\\n    def committer_date(self) -> datetime:\\n        \\\"\\\"\\\"\\n        Return the committed datetime.\\n\\n        :return: datetime committer_datetime\\n        \\\"\\\"\\\"\\n        return self._c_object.committed_datetime\\n\\n    @property\\n    def author_timezone(self) -> int:\\n        \\\"\\\"\\\"\\n        Author timezone expressed in seconds from epoch.\\n\\n        :return: int timezone\\n        \\\"\\\"\\\"\\n        return self._c_object.author_tz_offset\\n\\n    @property\\n    def committer_timezone(self) -> int:\\n        \\\"\\\"\\\"\\n        Author timezone expressed in seconds from epoch.\\n\\n        :return: int timezone\\n        \\\"\\\"\\\"\\n        return self._c_object.committer_tz_offset\\n\\n    @property\\n    def msg(self) -> str:\\n        \\\"\\\"\\\"\\n        Return commit message.\\n\\n        :return: str commit_message\\n        \\\"\\\"\\\"\\n        return self._c_object.message.strip()\\n\\n    @property\\n    def parents(self) -> List[str]:\\n        \\\"\\\"\\\"\\n        Return the list of parents SHAs.\\n\\n        :return: List[str] parents\\n        \\\"\\\"\\\"\\n        parents = []\\n        for p in self._c_object.parents:\\n            parents.append(p.hexsha)\\n        return parents\\n\\n    @property\\n    def merge(self) -> bool:\\n        \\\"\\\"\\\"\\n        Return True if the commit is a merge, False otherwise.\\n\\n        :return: bool merge\\n        \\\"\\\"\\\"\\n        return len(self._c_object.parents) > 1\\n\\n    @property\\n    def modifications(self) -> List[Modification]:\\n        \\\"\\\"\\\"\\n        Return a list of modified files.\\n\\n        :return: List[Modification] modifications\\n        \\\"\\\"\\\"\\n        if self._modifications is None:\\n            self._modifications = self._get_modifications()\\n\\n        return self._modifications\\n\\n    def _get_modifications(self):\\n        repo = Repo(str(self.project_path))\\n        commit = self._c_object\\n\\n        if len(self.parents) == 1:\\n            # the commit has a parent\\n            diff_index = self._c_object.parents[0].diff(commit,\\n                                                        create_patch=True)\\n        elif len(self.parents) > 1:\\n            # if it's a merge commit, the modified files of the commit are the\\n            # conflicts. This because if the file is not in conflict,\\n            # pydriller will visit the modification in one of the previous\\n            # commits. However, parsing the output of a combined diff (that\\n            # returns the list of conflicts) is challenging: so, right now,\\n            # I will return an empty array, in the meanwhile I will try to\\n            # find a way to parse the output.\\n            # c_git = Git(str(self.project_path))\\n            # d = c_git.diff_tree(\\\"--cc\\\", commit.hexsha, '-r', '--abbrev=40',\\n            #                     '--full-index', '-M', '-p', '--no-color')\\n            diff_index = []\\n        else:\\n            # this is the first commit of the repo. Comparing it with git\\n            # NULL TREE\\n            parent = repo.tree(NULL_TREE)\\n            diff_index = parent.diff(commit.tree, create_patch=True)\\n\\n        return self._parse_diff(diff_index)\\n\\n    def _parse_diff(self, diff_index) -> List[Modification]:\\n        modifications_list = []\\n        for diff in diff_index:\\n            old_path = diff.a_path\\n            new_path = diff.b_path\\n            change_type = self._from_change_to_modification_type(diff)\\n\\n            diff_and_sc = {\\n                'diff': self._get_decoded_str(diff.diff),\\n                'source_code_before': self._get_decoded_sc_str(\\n                    diff.a_blob),\\n                'source_code': self._get_decoded_sc_str(\\n                    diff.b_blob)\\n            }\\n\\n            modifications_list.append(Modification(old_path, new_path,\\n                                                   change_type, diff_and_sc))\\n\\n        return modifications_list\\n\\n    def _get_decoded_str(self, diff):\\n        try:\\n            return diff.decode('utf-8', 'ignore')\\n        except (UnicodeDecodeError, AttributeError, ValueError):\\n            logger.debug('Could not load the diff of a '\\n                         'file in commit %s', self._c_object.hexsha)\\n            return None\\n\\n    def _get_decoded_sc_str(self, diff):\\n        try:\\n            return diff.data_stream.read().decode('utf-8', 'ignore')\\n        except (UnicodeDecodeError, AttributeError, ValueError):\\n            logger.debug('Could not load source code of a '\\n                         'file in commit %s', self._c_object.hexsha)\\n            return None\\n\\n    @property\\n    def in_main_branch(self) -> bool:\\n        \\\"\\\"\\\"\\n        Return True if the commit is in the main branch, False otherwise.\\n\\n        :return: bool in_main_branch\\n        \\\"\\\"\\\"\\n        return self._main_branch in self.branches\\n\\n    @property\\n    def branches(self) -> Set[str]:\\n        \\\"\\\"\\\"\\n        Return the set of branches that contain the commit.\\n\\n        :return: set(str) branches\\n        \\\"\\\"\\\"\\n        if self._branches is None:\\n            self._branches = self._get_branches()\\n\\n        return self._branches\\n\\n    def _get_branches(self):\\n        c_git = Git(str(self.project_path))\\n        branches = set()\\n        for branch in set(c_git.branch('--contains', self.hash).split('\\n')):\\n            branches.add(branch.strip().replace('* ', ''))\\n        return branches\\n\\n    # pylint disable=R0902\\n    def _from_change_to_modification_type(self, diff: Diff):\\n        if diff.new_file:\\n            return ModificationType.ADD\\n        if diff.deleted_file:\\n            return ModificationType.DELETE\\n        if diff.renamed_file:\\n            return ModificationType.RENAME\\n        if diff.a_blob and diff.b_blob and diff.a_blob != diff.b_blob:\\n            return ModificationType.MODIFY\\n\\n        return ModificationType.UNKNOWN\\n\\n    def __eq__(self, other):\\n        if not isinstance(other, Commit):\\n            return NotImplemented\\n        if self is other:\\n            return True\\n\\n        return self.__dict__ == other.__dict__\\n\\n    def __str__(self): # pragma: no cover\\n        return (\\n            'Hash: {}\\n'.format(self.hash) +\\n            'Author: {}\\n'.format(self.author.name) +\\n            'Author email: {}\\n'.format(self.author.email) +\\n            'Committer: {}\\n'.format(self.committer.name) +\\n            'Committer email: {}\\n'.format(self.committer.email) +\\n            'Author date: {}\\n'.format(\\n                self.author_date.strftime(\\\"%Y-%m-%d %H:%M:%S\\\")) +\\n            'Committer date: {}\\n'.format(\\n                self.committer_date.strftime(\\\"%Y-%m-%d %H:%M:%S\\\")) +\\n            'Message: {}\\n'.format(self.msg) +\\n            'Parent: {}\\n'.format(\\\"\\n\\\".join(map(str, self.parents))) +\\n            'Merge: {}\\n'.format(self.merge) +\\n            'Modifications: \\n{}'.format(\\n                \\\"\\n\\\".join(map(str, self.modifications))) +\\n            'Branches: \\n{}'.format(\\\"\\n\\\".join(map(str, self.branches))) +\\n            'In main branch: {}\\n'.format(self.in_main_branch)\\n        )\\n\\\"\\\"\\\"\\nTest which tests class Commit and dmm_unit_complexity. For the test use test-repos/dmm-test-repo. Assert the dmm_unit_complexity to be 1.0\\n\\\"\\\"\\\"\\ndef test_\\n\\nif __name__ == '__main__':\\n    from pydriller import RepositoryMining\\n    from pydriller.domain.commit import Commit\\n    from pydriller.metrics.process.dmm_unit_complexity import DMMUnitComplexity\\n    from pydriller.metrics.process.dmm_unit_complexity import DMMUnitComplexity\\n    from pydriller.metrics.process.dmm_unit_complexity import DMMUnitComplexity\\n    from pydriller.metrics.process.dmm_unit_complexity import DMMUnitComplexity\\n    from pydriller.metrics.process.dmm_unit_complexity import DMMUnitComplexity\\n    from pydriller.metrics.process.dmm_unit_complexity import DMMUnitComplexity\\n    from pydriller.metrics.process.dmm_unit_complexity import DMMUnitComplexity\\n    from pydriller.metrics.process.dmm_unit_complexity import DMMUnitComplexity\\n    from\"\n",
      "    }\n",
      "  ],\n",
      "  \"created\": 1656685002,\n",
      "  \"id\": \"cmpl-5PBjmv9H1MrOB4oPXbJWkP2mO3uRW\",\n",
      "  \"model\": \"code-davinci-002\",\n",
      "  \"object\": \"text_completion\",\n",
      "  \"usage\": {\n",
      "    \"completion_tokens\": 1024,\n",
      "    \"prompt_tokens\": 4430,\n",
      "    \"total_tokens\": 5454\n",
      "  }\n",
      "}\n"
     ]
    }
   ],
   "source": [
    "import openai\n",
    "import os\n",
    "openai.api_key = os.getenv(\"OPENAI_API_KEY\")\n",
    "response = openai.Completion.create(\n",
    "                engine=\"code-davinci-002\",\n",
    "                prompt=prompt,\n",
    "                temperature=0,\n",
    "                max_tokens=256,\n",
    "                n=4,\n",
    "                frequency_penalty=0,\n",
    "                presence_penalty=0,\n",
    "                echo=True,\n",
    "                stop=[\"#\"]\n",
    ")\n",
    "print(response)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "import ast\n",
    "gen_code = response['choices'][3]['text']"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "from generation.Model import Model\n",
    "\n",
    "m = Model()\n",
    "code = m.generate_test(prompt)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "res = m.complete(prompt)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "import re\n",
    "import ast\n",
    "def compile_code(code, depth=90):\n",
    "    if depth == 0:\n",
    "        print(\"Couldn't make compilable for code\")\n",
    "        return code\n",
    "    try:\n",
    "        ast.parse(code)\n",
    "        return code\n",
    "    except SyntaxError as e:\n",
    "        lines = code.split(\"\\n\")\n",
    "        line_number = re.findall(r\"line (\\d+)\", e.__str__())[0]\n",
    "        print(\"Syntax Error:\", line_number, e)\n",
    "        lines.pop(int(line_number) - 1)\n",
    "        return compile_code(\"\\n\".join(lines), depth - 1)\n",
    "    except NameError as e:\n",
    "        print(\"Name error: \", e)\n",
    "        return code"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "compile_code(res[0])"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "import openai\n",
    "openai.api_key = os.getenv(\"OPENAI_API_KEY\")\n",
    "response = openai.Edit.create(\n",
    "            model=\"code-davinci-edit-001\",\n",
    "            input='''\n",
    "###Python3\n",
    "import pytest\n",
    "\n",
    "def test_calculator_can_calculate_equation_with_plus_operator():\n",
    "\n",
    "    operators = [PlusOperator()]\n",
    "\n",
    "    calc = Calculator(operators)\n",
    "\n",
    "    assert calc.calculate(\"1 + 2 + 4 + 5\") == 12\n",
    "\n",
    "    assert calc.calculate(\"10+10+10\") == 30\n",
    "\n",
    "\"\"\"\n",
    "\n",
    "Added basic Calucator functionality.\n",
    "\n",
    "Calculator should be able to calculate equations with PlusOperator as follows:\n",
    "\n",
    "1+2+4+5=12\n",
    "\n",
    "10+10+10=30\n",
    "\n",
    "The tests are testing: class Calculator\n",
    "\n",
    "\"\"\"\n",
    "\n",
    "def test_calculator_can_calculate_equation_with_plus_operator():\n",
    "\n",
    "    operators = [PlusOperator()]\n",
    "\n",
    "    calc = Calculator(operators)\n",
    "\n",
    "    assert calc.calculate(\"1+2+4+5\") == 12\n",
    "\n",
    "    assert calc.calculate(\"10+10+10\n",
    "''',\n",
    "            instruction=\"Fix compilation\",\n",
    "            temperature=0,\n",
    "            top_p=1\n",
    "        )"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "print(response['choices'][0]['text'])"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "outputs": [],
   "source": [
    "prompt='''\n",
    "\n",
    "\n",
    "import pytest\n",
    "\n",
    "def test_multiply_operation():\n",
    "\n",
    "    operators = [MultiplyOperator()]\n",
    "\n",
    "    calc = Calculator(operators)\n",
    "\n",
    "    result = calc.calculate(\"2*4=\")\n",
    "\n",
    "\n",
    "\n",
    "    assert 8 == result\n",
    "\n",
    "def test_plus_and_multiply_operation():\n",
    "\n",
    "    operators = [PlusOperator(), MultiplyOperator()]\n",
    "\n",
    "    calc = Calculator(operators)\n",
    "\n",
    "\n",
    "\n",
    "    for line in [\"2+10*3=\", \"2*10+3=\", \"5+6*7=\"]:\n",
    "\n",
    "        print(line, end=' ')\n",
    "\n",
    "        result = calc.calculate(line)\n",
    "\n",
    "\n",
    "\n",
    "        assert int(line[:-1].replace('+', '').replace('*', '')) + (int(line[0]) * int(line[-2])) == result\n",
    "\n",
    "# Generate asserts\n",
    "\n",
    "import pytest\n",
    "\n",
    "\"\"\"\n",
    "\n",
    "Added support for MultiplyOperations.\n",
    "\n",
    "Calculator should be able to handle equations of:\n",
    "\n",
    "2*4=8\n",
    "\n",
    "and support both multiplication and sumarization like:\n",
    "\n",
    "2+10*2=22\n",
    "\n",
    "The tests are testing: class Calculator\n",
    "\n",
    "\"\"\"\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "def test_multiply_operation(): ...\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "def test_plus_and_multiply_operation(): ...\n",
    "'''"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "outputs": [
    {
     "data": {
      "text/plain": "<OpenAIObject edit at 0x1f4fe83be50> JSON: {\n  \"choices\": [\n    {\n      \"index\": 0,\n      \"text\": \"import pytest\\ndef test_multiply_operation():\\n    operators = [MultiplyOperator()]\\n    calc = Calculator(operators)\\n    result = calc.calculate(\\\"2*4=\\\")\\n\\n    assert 8 == result\\ndef test_plus_and_multiply_operation():\\n    operators = [PlusOperator(), MultiplyOperator()]\\n    calc = Calculator(operators)\\n\\n    for line in [\\\"2+10*3=\\\", \\\"2*10+3=\\\", \\\"5+6*7=\\\"]:\\n        print(line, end=' ')\\n        result = calc.calculate(line)\\n\\n        assert int(line[:-1].replace('+', '').replace('*', '')) + (int(line[0]) * int(line[-2])) == result\\n# Generate asserts\\nimport pytest\\n\\\"\\\"\\\"\\nAdded support for MultiplyOperations.\\nCalculator should be able to handle equations of:\\n2*4=8\\nand support both multiplication and sumarization like:\\n2+10*2=22\\nThe tests are testing: class Calculator\\n\\\"\\\"\\\"\\n\\n \\ndef test_multiply_operation(): ...\\n\\n\\n \\n\\ndef test_plus_and_multiply_operation(): ...\\n\"\n    }\n  ],\n  \"created\": 1656685165,\n  \"object\": \"edit\",\n  \"usage\": {\n    \"completion_tokens\": 304,\n    \"prompt_tokens\": 331,\n    \"total_tokens\": 635\n  }\n}"
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "openai.Edit.create(\n",
    "                model=\"code-davinci-edit-001\",\n",
    "                input=prompt,\n",
    "                instruction=\"Fix compilation\",\n",
    "                temperature=0,\n",
    "                top_p=1\n",
    "            )"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}