xlsx-run-tool

.github/workflows/build.yml

@@ -22,6 +22,7 @@ jobs:
         pip install flake8 pytest
         pip install -r requirements.txt
         pip install -r requirements-test.txt
+        pip install -r requirements-evaluation.txt
     - name: Lint with flake8
       run: |
         # stop the build if there are Python syntax errors or undefined names
@@ -38,6 +39,14 @@ jobs:
         java-version: '11'
     - name: Check java version
       run: java -version
+
     - name: Test with pytest
       run: |
         pytest
+    - name: Upload pytest test results
+      uses: actions/upload-artifact@v2
+      with:
+        name: pytest-results-${{ matrix.python-version }}
+        path: test
+      # Use always() to always run this step to publish test results when there are test failures
+      if: ${{ always() }}

README.md

@@ -79,6 +79,7 @@ Simply clone the repository and run the following commands:
 
 1. `pip install -r requirements.txt`
 2. `pip install -r requirements-test.txt` for tests
+3. `pip install -r requirements-evaluation.txt` for evaluation
 
 ## Usage
 

requirements-evaluation.txt

@@ -0,0 +1,2 @@
+openpyxl==3.0.7
+pandas==1.2.3

requirements.txt

@@ -27,3 +27,4 @@ radon==4.5.0
 # extra libraries and frameworks
 django==3.2
 requests==2.25.1
+argparse==1.4.0

src/python/common/tool_arguments.py

@@ -0,0 +1,74 @@
+from dataclasses import dataclass
+from enum import Enum, unique
+from typing import List, Optional
+
+from src.python.review.application_config import LanguageVersion
+from src.python.review.inspectors.inspector_type import InspectorType
+
+
+@unique
+class VerbosityLevel(Enum):
+    """
+    Same meaning as the logging level. Should be used in command-line args.
+    """
+    DEBUG = '3'
+    INFO = '2'
+    ERROR = '1'
+    DISABLE = '0'
+
+    @classmethod
+    def values(cls) -> List[str]:
+        return [member.value for member in VerbosityLevel.__members__.values()]
+
+
+@dataclass(frozen=True)
+class ArgumentsInfo:
+    short_name: Optional[str]
+    long_name: str
+    description: str
+
+
+@unique
+class RunToolArgument(Enum):
+    VERBOSITY = ArgumentsInfo('-v', '--verbosity',
+                              'Choose logging level: '
+                              f'{VerbosityLevel.ERROR.value} - ERROR; '
+                              f'{VerbosityLevel.INFO.value} - INFO; '
+                              f'{VerbosityLevel.DEBUG.value} - DEBUG; '
+                              f'{VerbosityLevel.DISABLE.value} - disable logging; '
+                              'default is 0')
+
+    inspectors = [inspector.lower() for inspector in InspectorType.available_values()]
+    disabled_inspectors_example = f'-d {inspectors[0].lower()},{inspectors[1].lower()}'
+
+    DISABLE = ArgumentsInfo('-d', '--disable',
+                            'Disable inspectors. '
+                            f'Available values: {", ".join(inspectors)}. '
+                            f'Example: {disabled_inspectors_example}')
+
+    DUPLICATES = ArgumentsInfo(None, '--allow-duplicates',
+                               'Allow duplicate issues found by different linters. '
+                               'By default, duplicates are skipped.')
+
+    LANG_VERSION = ArgumentsInfo(None, '--language-version',
+                                 'Specify the language version for JAVA inspectors.'
+                                 'Available values are: '
+                                 f'{LanguageVersion.PYTHON_3.value}, {LanguageVersion.JAVA_8.value}, '
+                                 f'{LanguageVersion.JAVA_11.value}, {LanguageVersion.KOTLIN.value}.')
+
+    CPU = ArgumentsInfo(None, '--n-cpu',
+                        'Specify number of cpu that can be used to run inspectors')
+
+    PATH = ArgumentsInfo(None, 'path', 'Path to file or directory to inspect.')
+
+    FORMAT = ArgumentsInfo('-f', '--format',
+                           'The output format. Default is JSON.')
+
+    START_LINE = ArgumentsInfo('-s', '--start-line',
+                               'The first line to be analyzed. It starts from 1.')
+
+    END_LINE = ArgumentsInfo('-e', '--end-line', 'The end line to be analyzed or None.')
+
+    NEW_FORMAT = ArgumentsInfo(None, '--new-format',
+                               'The argument determines whether the tool '
+                               'should use the new format')

src/python/evaluation/README.md

@@ -0,0 +1,31 @@
+# Hyperstyle evaluation
+
+This tool allows running the `Hyperstyle` tool on an xlsx table to get code quality for all code fragments. Please, note that your input file should consist of at least 2 obligatory columns to run xlsx-tool on its code fragments:
+
+- `code`
+- `lang`
+
+Possible values for column `lang` are: `python3`, `kotlin`, `java8`, `java11`.
+
+Output file is a new `xlsx` file with 3 columns:
+- `code`
+- `lang`
+- `grade`
+Grade assessment is conducted by [`run_tool.py`](https://github.com/hyperskill/hyperstyle/blob/main/README.md) with default arguments. Avaliable values for column  `grade` are: BAD, MODERATE, GOOD, EXCELLENT. It is also possible add fourth column: `traceback` to get full inspectors feedback on each code fragment. More details on enabling traceback column in **Optional Arguments** table.
+
+## Usage
+
+Run the [xlsx_run_tool.py](xlsx_run_tool.py) with the arguments from command line.
+
+Required arguments:
+
+`xlsx_file_path` — path to xlsx-file with code samples to inspect.
+
+Optional arguments:
+Argument | Description
+--- | ---
+|**‑f**, **‑‑format**| The output format. Available values: `json`, `text`. The default value is `json` . Use this argument when `traceback` is enabled, otherwise it will not be used.|
+|**‑tp**, **‑‑tool_path**| Path to run-tool. Default is `src/python/review/run_tool.py` .|
+|**‑tr**, **‑‑traceback**| To include a column with errors traceback into an output file. Default is `False`.|
+|**‑ofp**, **‑‑output_folder_path**| An explicit folder path to store file with results. Default is a parent directory of a folder with xlsx-file sent for inspection. |
+|**‑ofn**, **‑‑output_file_name**| A name of an output file where evaluation results will be stored. Default is `results.xlsx`.|

src/python/evaluation/common/util.py

@@ -0,0 +1,34 @@
+from enum import Enum, unique
+
+from src.python.review.application_config import LanguageVersion
+from src.python.review.common.file_system import Extension
+
+
+@unique
+class ColumnName(Enum):
+    CODE = "code"
+    LANG = "lang"
+    LANGUAGE = "language"
+    GRADE = "grade"
+
+
+@unique
+class EvaluationArgument(Enum):
+    TRACEBACK = "traceback"
+    RESULT_FILE_NAME = "results"
+    RESULT_FILE_NAME_EXT = f"{RESULT_FILE_NAME}{Extension.XLSX.value}"
+
+
+script_structure_rule = ("Please, make sure your XLSX-file matches following script standards: \n"
+                         "1. Your XLSX-file should have 2 obligatory columns named:"
+                         f"'{ColumnName.CODE.value}' & '{ColumnName.LANG.value}'. \n"
+                         f"'{ColumnName.CODE.value}' column -- relates to the code-sample. \n"
+                         f"'{ColumnName.LANG.value}' column -- relates to the language of a "
+                         "particular code-sample. \n"
+                         "2. Your code samples should belong to the one of the supported languages. \n"
+                         "Supported languages are: Java, Kotlin, Python. \n"
+                         f"3. Check that '{ColumnName.LANG.value}' column cells are filled with "
+                         "acceptable language-names: \n"
+                         f"Acceptable language-names are: {LanguageVersion.PYTHON_3.value}, "
+                         f"{LanguageVersion.JAVA_8.value} ,"
+                         f"{LanguageVersion.JAVA_11.value} and {LanguageVersion.KOTLIN.value}.")

src/python/evaluation/common/xlsx_util.py

@@ -0,0 +1,42 @@
+import logging.config
+from pathlib import Path
+from typing import Union
+
+import pandas as pd
+from openpyxl import load_workbook, Workbook
+from src.python.evaluation.evaluation_config import EvaluationConfig
+
+logger = logging.getLogger(__name__)
+
+
+def remove_sheet(workbook_path: Union[str, Path], sheet_name: str, to_raise_error: bool = False) -> None:
+    try:
+        workbook = load_workbook(workbook_path)
+        workbook.remove(workbook[sheet_name])
+        workbook.save(workbook_path)
+
+    except KeyError as e:
+        message = f'Sheet with specified name: {sheet_name} does not exist.'
+        if to_raise_error:
+            logger.exception(message)
+            raise e
+        else:
+            logger.info(message)
+
+
+def create_and_get_workbook_path(config: EvaluationConfig) -> Path:
+    workbook = Workbook()
+    workbook_path = config.get_output_file_path()
+    workbook.save(workbook_path)
+    return workbook_path
+
+
+def write_dataframe_to_xlsx_sheet(xlsx_file_path: Union[str, Path], df: pd.DataFrame, sheet_name: str,
+                                  mode: str = 'a', to_write_row_names: bool = False) -> None:
+    """
+    mode: str Available values are {'w', 'a'}. File mode to use (write or append).
+    to_write_row_names: bool Write row names.
+    """
+
+    with pd.ExcelWriter(xlsx_file_path, mode=mode) as writer:
+        df.to_excel(writer, sheet_name=sheet_name, index=to_write_row_names)

src/python/evaluation/evaluation_config.py

@@ -0,0 +1,43 @@
+import logging.config
+from argparse import Namespace
+from pathlib import Path
+from typing import List, Union
+
+from src.python.common.tool_arguments import RunToolArgument
+from src.python.evaluation.common.util import EvaluationArgument
+from src.python.review.application_config import LanguageVersion
+from src.python.review.common.file_system import create_directory
+
+logger = logging.getLogger(__name__)
+
+
+class EvaluationConfig:
+    def __init__(self, args: Namespace):
+        self.tool_path: Union[str, Path] = args.tool_path
+        self.output_format: str = args.format
+        self.xlsx_file_path: Union[str, Path] = args.xlsx_file_path
+        self.traceback: bool = args.traceback
+        self.output_folder_path: Union[str, Path] = args.output_folder_path
+        self.output_file_name: str = args.output_file_name
+
+    def build_command(self, inspected_file_path: Union[str, Path], lang: str) -> List[str]:
+        command = [LanguageVersion.PYTHON_3.value,
+                   self.tool_path,
+                   inspected_file_path,
+                   RunToolArgument.FORMAT.value.short_name, self.output_format]
+
+        if lang == LanguageVersion.JAVA_8.value or lang == LanguageVersion.JAVA_11.value:
+            command.extend([RunToolArgument.LANG_VERSION.value.long_name, lang])
+        return command
+
+    def get_output_file_path(self) -> Path:
+        if self.output_folder_path is None:
+            try:
+                self.output_folder_path = (
+                    Path(self.xlsx_file_path).parent.parent / EvaluationArgument.RESULT_FILE_NAME.value
+                )
+                create_directory(self.output_folder_path)
+            except FileNotFoundError as e:
+                logger.error('XLSX-file with the specified name does not exists.')
+                raise e
+        return Path(self.output_folder_path) / self.output_file_name