docchecker 0.1.3

A tool to detect the inconsistent between code and text in your source code

DocChecker: Bootstrapping Code-Text Pretrained Language Model to Detect Inconsistency Between Code and Comment

---

DocChecker Package

DocChecker is trained on top of encoder-decoder model to learn from code-text pairs. It is a tool that uses for automated detection to identify inconsistencies between code and docstrings, and generates comprehensive summary sentence to replace the old ones.

Usage Scenario

Installation

Install the dependencies:

pip -r install requirements.txt

Inference

Since DocChecker is a Python package, users can use it by inference function.

from DocChecker.utils import inference

Parameters:

• input_file_path (str): the file path that contains source code if users want to check all the functions in there.

• raw_code (str): a sequence of source code if input_file_path is not given.

• language (str, required): the programming language. We support 10 popular programming languages such as Java, JavaScript, Python, Ruby, Rust, Golang, C#, C++, C, and PHP.

• output_file_path (str): if it is not None, the results from our tool will be written in this path; otherwise, they will be printed on the screen. Returns:

• list of dictionaries, including:

  • function_name: the name of each function in the raw code
  • code: code snippet
  • docstring: the docstring corresponding code snippet
  • predict: the prediction of DocChecker. It returns "Inconsistent!” for the inconsistent pair and “Consistent!” means the docstring is consistent with the code in a code-text pair
  • recommend_docstring: If a code-text pair is considered as “Inonsistent!”, DocChecker will give a comprehensive docstring to replace its docstring, otherwise, it will keep the original version.

Example

from DocChecker.utils import inference

code = """
def inject_func_as_unbound_method(class_, func, method_name=None):
    # This is actually quite simple
    if method_name is None:
        method_name = get_funcname(func)
    setattr(class_, method_name, func)

def e(message, exit_code=None):
    # Print an error log message.
    print_log(message, YELLOW, BOLD)
    if exit_code is not None:
        sys.exit(exit_code)
"""

inference(raw_code=code, language='python')

>>> [
    {
    "function_name": "inject_func_as_unbound_method",
    "code": "def inject_func_as_unbound_method(class_, func, method_name=None):\n    \n    if method_name is None:\n        method_name = get_funcname(func)\n    setattr(class_, method_name, func)",
    "docstring": " This is actually quite simple",
    "predict": "Inconsistent!",
    "recommended_docstring": "Inject a function as an unbound method."
	},
	{
	    "function_name": "e",
	    "code": "def e(message, exit_code=None):\n    \n    print_log(message, YELLOW, BOLD)\n    if exit_code is not None:\n        sys.exit(exit_code)",
	    "docstring": "Print an error log message.",
	    "predict": "Consistent!",
	    "recommended_docstring": "Print an error log message."
	}
	]

Reference

More details can be found in our paper. If you use this code or our package, please consider citing us:

@article{DocChecker,
  title={Bootstrapping Code-Text Pretrained Language Model to Detect Inconsistency Between Code and Comment},
  author={},
  journal={},
  pages={},
  year={2023}
}

Contact us

If you have any questions, comments or suggestions, please do not hesitate to contact us.

• Website: fpt-aicenter
• Email: [e-mail]

License

MIT License