codecov-cli 0.3.2__tar.gz → 0.3.4__tar.gz

{codecov-cli-0.3.2/codecov_cli.egg-info → codecov-cli-0.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: codecov-cli
-Version: 0.3.2
+Version: 0.3.4
 Summary: Codecov Command Line Interface
 Author: Codecov
 Author-email: support@codecov.io

codecov-cli-0.3.4/codecov_cli/__init__.py

@@ -0,0 +1,4 @@
+with open("VERSION", encoding="utf-8") as f:
+    version_number = f.readline().strip()
+
+__version__ = version_number

{codecov-cli-0.3.2 → codecov-cli-0.3.4}/codecov_cli/commands/labelanalysis.py

@@ -1,3 +1,4 @@
+import json
 import logging
 import pathlib
 import time
@@ -55,13 +56,23 @@ logger = logging.getLogger("codecovcli")
 @click.option(
     "--dry-run",
     "dry_run",
-    help='Print list of tests to run and options that need to be added to the test runner as a space-separated list to stdout. Format is ATS_TESTS_TO_RUN="<options> <test_1> <test_2> ... <test_n>"',
+    help=(
+        "Print list of tests to run AND tests skipped (and options that need to be added to the test runner) to stdout. "
+        + "Also prints the same information in JSON format. "
+        + "JSON will have keys 'ats_tests_to_run', 'ats_tests_to_skip' and 'runner_options'. "
+        + "List of tests to run is prefixed with ATS_TESTS_TO_RUN= "
+        + "List of tests to skip is prefixed with ATS_TESTS_TO_SKIP="
+    ),
     is_flag=True,
 )
 @click.option(
     "--dry-run-output-path",
     "dry_run_output_path",
-    help="Prints the dry-run list into dry_run_output_path (in addition to stdout)",
+    help=(
+        "Prints the dry-run list (ATS_TESTS_TO_RUN) into dry_run_output_path (in addition to stdout)\n"
+        + "AND prints ATS_TESTS_TO_SKIP into dry_run_output_path_skipped\n"
+        + "AND prints dry-run JSON output into dry_run_output_path.json"
+    ),
     type=pathlib.Path,
     default=None,
 )
@@ -313,18 +324,50 @@ def _dry_run_output(
     runner: LabelAnalysisRunnerInterface,
     dry_run_output_path: Optional[pathlib.Path],
 ):
-    labels_to_run = list(
-        set(
-            result.absent_labels
-            + result.global_level_labels
-            + result.present_diff_labels
-        )
+    labels_to_run = set(
+        result.absent_labels + result.global_level_labels + result.present_diff_labels
+    )
+    labels_skipped = set(result.present_report_labels) - labels_to_run
+    # If the test label can contain spaces and dashes the test runner might
+    # interpret it as an option and not a label
+    # So we wrap it in doublequotes just to be extra sure
+    labels_run_wrapped_double_quotes = sorted(
+        map(lambda l: '"' + l + '"', labels_to_run)
+    )
+    labels_skip_wrapped_double_quotes = sorted(
+        map(lambda l: '"' + l + '"', labels_skipped)
+    )
+
+    output_as_dict = dict(
+        runner_options=runner.dry_run_runner_options,
+        ats_tests_to_run=labels_run_wrapped_double_quotes,
+        ats_tests_to_skip=labels_skip_wrapped_double_quotes,
     )
-    output = runner.dry_run_runner_options + sorted(labels_to_run)
     if dry_run_output_path is not None:
         with open(dry_run_output_path, "w") as fd:
-            fd.write(" ".join(output) + "\n")
-    click.echo(f"ATS_TESTS_TO_RUN=\"{' '.join(output)}\"")
+            fd.write(
+                " ".join(
+                    runner.dry_run_runner_options + labels_run_wrapped_double_quotes
+                )
+                + "\n"
+            )
+        with open(str(dry_run_output_path) + "_skipped", "w") as fd:
+            fd.write(
+                " ".join(
+                    runner.dry_run_runner_options + labels_skip_wrapped_double_quotes
+                )
+                + "\n"
+            )
+        with open(str(dry_run_output_path) + ".json", "w") as fd:
+            fd.write(json.dumps(output_as_dict) + "\n")
+
+    click.echo(json.dumps(output_as_dict))
+    click.echo(
+        f"ATS_TESTS_TO_RUN={' '.join(runner.dry_run_runner_options + labels_run_wrapped_double_quotes)}"
+    )
+    click.echo(
+        f"ATS_TESTS_TO_SKIP={' '.join(runner.dry_run_runner_options + labels_skip_wrapped_double_quotes)}"
+    )
 
 
 def _fallback_to_collected_labels(

{codecov-cli-0.3.2 → codecov-cli-0.3.4}/codecov_cli/commands/upload.py

@@ -65,6 +65,12 @@ _global_upload_options = [
         is_flag=True,
         default=False,
     ),
+    click.option(
+        "--disable-file-fixes",
+        help="Disable file fixes to ignore common lines from coverage (e.g. blank lines or empty brackets)",
+        is_flag=True,
+        default=False,
+    ),
     click.option(
         "-b",
         "--build",
@@ -178,6 +184,7 @@ def do_upload(
     coverage_files_search_exclude_folders: typing.List[pathlib.Path],
     coverage_files_search_explicitly_listed_files: typing.List[pathlib.Path],
     disable_search: bool,
+    disable_file_fixes: bool,
     token: typing.Optional[uuid.UUID],
     plugin_names: typing.List[str],
     branch: typing.Optional[str],
@@ -218,6 +225,7 @@ def do_upload(
                 git_service=git_service,
                 enterprise_url=enterprise_url,
                 disable_search=disable_search,
+                disable_file_fixes=disable_file_fixes,
                 handle_no_reports_found=handle_no_reports_found,
             )
         ),
@@ -254,4 +262,5 @@ def do_upload(
         enterprise_url=enterprise_url,
         disable_search=disable_search,
         handle_no_reports_found=handle_no_reports_found,
+        disable_file_fixes=disable_file_fixes,
     )

{codecov-cli-0.3.2 → codecov-cli-0.3.4}/codecov_cli/commands/upload_process.py

@@ -37,6 +37,7 @@ def upload_process(
     coverage_files_search_exclude_folders: typing.List[pathlib.Path],
     coverage_files_search_explicitly_listed_files: typing.List[pathlib.Path],
     disable_search: bool,
+    disable_file_fixes: bool,
     token: typing.Optional[uuid.UUID],
     plugin_names: typing.List[str],
     branch: typing.Optional[str],
@@ -72,6 +73,7 @@ def upload_process(
                 pull_request_number=pull_request_number,
                 git_service=git_service,
                 disable_search=disable_search,
+                disable_file_fixes=disable_file_fixes,
                 fail_on_error=fail_on_error,
                 handle_no_reports_found=handle_no_reports_found,
             )
@@ -123,4 +125,5 @@ def upload_process(
         dry_run=dry_run,
         git_service=git_service,
         handle_no_reports_found=handle_no_reports_found,
+        disable_file_fixes=disable_file_fixes,
     )

{codecov-cli-0.3.2 → codecov-cli-0.3.4}/codecov_cli/runners/python_standard_runner.py

@@ -1,17 +1,11 @@
 import logging
 import random
 import subprocess
-from contextlib import redirect_stdout
-from io import StringIO, TextIOWrapper
-from multiprocessing import Process, Queue, get_context
-from os import getcwd
-from queue import Empty
 from subprocess import CalledProcessError
-from sys import path, stdout
+from sys import stdout
 from typing import List, Optional
 
 import click
-import pytest
 
 from codecov_cli.runners.types import (
     LabelAnalysisRequestResult,
@@ -43,58 +37,6 @@ class PythonStandardRunnerConfigParams(dict):
         """
         return self.get("coverage_root", "./")
 
-    @property
-    def strict_mode(self) -> bool:
-        """
-        Run pytest from within Python instead of using subprocess.run
-        This is potentailly safer than using subprocess.run because it guarantees better that
-        the program running is indeed pytest.
-        But it might not work everytime due to import issues related to Python caching modules.
-        """
-        return self.get("strict_mode", False)
-
-
-def _include_curr_dir(method):
-    """
-    Account for the difference 'pytest' vs 'python -m pytest'
-    https://docs.pytest.org/en/7.1.x/how-to/usage.html#calling-pytest-through-python-m-pytest
-    Used only in strict_mode
-    """
-
-    def call_method(self, *args, **kwargs):
-        curr_dir = getcwd()
-        path.append(curr_dir)
-
-        result = method(self, *args, **kwargs)
-
-        path.remove(curr_dir)
-        return result
-
-    return call_method
-
-
-def _execute_pytest_subprocess(
-    pytest_args: List[str],
-    queue: Queue,
-    parent_stdout: TextIOWrapper,
-    capture_output: bool = True,
-):
-    """Runs pytest from python in a subprocess.
-    This is because we call it twice in the label-analysis process,
-    so we might have import errors if calling it directly.
-    Check the warning: https://docs.pytest.org/en/7.1.x/how-to/usage.html#calling-pytest-from-python-code
-
-    Returns the output value and pytest exit code via queue
-    """
-    subproces_stdout = parent_stdout
-    if capture_output:
-        subproces_stdout = StringIO()
-    with redirect_stdout(subproces_stdout):
-        result = pytest.main(pytest_args)
-    if capture_output:
-        queue.put({"output": subproces_stdout.getvalue()})
-    queue.put({"result": result})
-
 
 class PythonStandardRunner(LabelAnalysisRunnerInterface):
 
@@ -106,54 +48,6 @@ class PythonStandardRunner(LabelAnalysisRunnerInterface):
             config_params = {}
         self.params = PythonStandardRunnerConfigParams(config_params)
 
-    def _wait_pytest(self, pytest_process: Process, queue: Queue):
-        pytest_process.start()
-        result = None
-        output = None
-        while pytest_process.exitcode == 0 or pytest_process.exitcode == None:
-            from_queue = None
-            try:
-                from_queue = queue.get(timeout=1)
-            except Empty:
-                pass
-            if from_queue and "output" in from_queue:
-                output = from_queue["output"]
-            if from_queue and "result" in from_queue:
-                result = from_queue["result"]
-            if result is not None:
-                break
-        pytest_process.join()
-        return result, output
-
-    @_include_curr_dir
-    def _execute_pytest_strict(
-        self, pytest_args: List[str], capture_output: bool = True
-    ) -> str:
-        """Handles calling pytest from Python in a subprocess.
-        Raises Exception if pytest fails
-        Returns the complete pytest output
-        """
-        ctx = get_context(method="fork")
-        queue = ctx.Queue(2)
-        p = ctx.Process(
-            target=_execute_pytest_subprocess,
-            args=[pytest_args, queue, stdout, capture_output],
-        )
-        result, output = self._wait_pytest(p, queue)
-
-        if p.exitcode != 0 or (result != pytest.ExitCode.OK and result != 0):
-            message = f"Pytest exited with non-zero code {result}."
-            message += "\nThis is likely not a problem with label-analysis. Check pytest's output and options."
-            if capture_output:
-                # If pytest failed but we captured its output the user won't know what's wrong
-                # So we need to include that in the error message
-                message += "\nPYTEST OUTPUT:"
-                message += "\n" + output
-            else:
-                message += "\n(you can check pytest options on the logs before the test session start)"
-            raise click.ClickException(message)
-        return output
-
     def parse_captured_output_error(self, exp: CalledProcessError) -> str:
         result = ""
         for out_stream in [exp.stdout, exp.stderr]:
@@ -202,10 +96,7 @@ class PythonStandardRunner(LabelAnalysisRunnerInterface):
             ),
         )
 
-        if self.params.strict_mode:
-            output = self._execute_pytest_strict(options_to_use)
-        else:
-            output = self._execute_pytest(options_to_use)
+        output = self._execute_pytest(options_to_use)
         lines = output.split(sep="\n")
         test_names = list(line for line in lines if ("::" in line and "test" in line))
         return test_names
@@ -254,10 +145,7 @@ class PythonStandardRunner(LabelAnalysisRunnerInterface):
             "List of tests executed",
             extra=dict(extra_log_attributes=dict(executed_tests=tests_to_run)),
         )
-        if self.params.strict_mode:
-            output = self._execute_pytest_strict(command_array, capture_output=False)
-        else:
-            output = self._execute_pytest(command_array, capture_output=False)
+        output = self._execute_pytest(command_array, capture_output=False)
         logger.info(f"Finished running {len(tests_to_run)} tests successfully")
         logger.info(f"  pytest options: \"{' '.join(default_options)}\"")
         logger.debug(output)

{codecov-cli-0.3.2 → codecov-cli-0.3.4}/codecov_cli/services/staticanalysis/__init__.py

@@ -36,24 +36,15 @@ async def run_analysis_entrypoint(
 ):
     ff = select_file_finder(config)
     files = list(ff.find_files(folder, pattern, folders_to_exclude))
-    logger.info(f"Running the analyzer on {len(files)} files")
-    mapped_func = partial(analyze_file, config)
-    all_data = {}
-    file_metadata = []
-    with click.progressbar(
-        length=len(files),
-        label="Analyzing files",
-    ) as bar:
-        with get_context("fork").Pool(processes=numberprocesses) as pool:
-            file_results = pool.imap_unordered(mapped_func, files)
-            for x in file_results:
-                bar.update(1, x)
-                if x is not None:
-                    res = x.asdict()["result"]
-                    all_data[x.filename] = res
-                    file_metadata.append(
-                        {"filepath": x.filename, "file_hash": res["hash"]}
-                    )
+    processing_results = await process_files(files, numberprocesses, config)
+    # Let users know if there were processing errors
+    # This is here and not in the funcition so we can add an option to ignore those (possibly)
+    # Also makes the function easier to test
+    processing_errors = processing_results["processing_errors"]
+    log_processing_errors(processing_errors)
+    # Upload results metadata to codecov to get list of files that we need to upload
+    file_metadata = processing_results["file_metadata"]
+    all_data = processing_results["all_data"]
     try:
         json_output = {"commit": commit, "filepaths": file_metadata}
         logger.debug(
@@ -118,7 +109,14 @@ async def run_analysis_entrypoint(
                 for el in files_that_need_upload:
                     all_tasks.append(send_single_upload_put(client, all_data, el))
                     bar.update(1, all_data[el["filepath"]])
-                resps = await asyncio.gather(*all_tasks)
+                try:
+                    resps = await asyncio.gather(*all_tasks)
+                except asyncio.CancelledError:
+                    message = (
+                        "Unknown error cancelled the upload tasks.\n"
+                        + f"Uploaded {len(uploaded_files)}/{len(files_that_need_upload)} files successfully."
+                    )
+                    raise click.ClickException(message)
             for resp in resps:
                 if resp["succeeded"]:
                     uploaded_files.append(resp["filepath"])
@@ -150,37 +148,91 @@ async def run_analysis_entrypoint(
             extra_log_attributes=dict(time_taken=response.elapsed.total_seconds())
         ),
     )
+    log_processing_errors(processing_errors)
 
 
-async def send_single_upload_put(client, all_data, el):
+def log_processing_errors(processing_errors: typing.Dict[str, str]) -> None:
+    if len(processing_errors) > 0:
+        logger.error(
+            f"{len(processing_errors)} files have processing errors and have been IGNORED."
+        )
+        for file, error in processing_errors.items():
+            logger.error(f"-> {file}: ERROR {error}")
+
+
+async def process_files(
+    files_to_analyze: typing.List[FileAnalysisRequest],
+    numberprocesses: int,
+    config: typing.Optional[typing.Dict],
+):
+    logger.info(f"Running the analyzer on {len(files_to_analyze)} files")
+    mapped_func = partial(analyze_file, config)
+    all_data = {}
+    file_metadata = []
+    errors = {}
+    with click.progressbar(
+        length=len(files_to_analyze),
+        label="Analyzing files",
+    ) as bar:
+        with get_context("fork").Pool(processes=numberprocesses) as pool:
+            file_results = pool.imap_unordered(mapped_func, files_to_analyze)
+            for result in file_results:
+                bar.update(1, result)
+                if result is not None:
+                    if result.result:
+                        all_data[result.filename] = result.result
+                        file_metadata.append(
+                            {
+                                "filepath": result.filename,
+                                "file_hash": result.result["hash"],
+                            }
+                        )
+                    elif result.error:
+                        errors[result.filename] = result.error
+    logger.info("All files have been processed")
+    return dict(
+        all_data=all_data, file_metadata=file_metadata, processing_errors=errors
+    )
+
+
+async def send_single_upload_put(client, all_data, el) -> typing.Dict:
     retryable_statuses = (429,)
     presigned_put = el["raw_upload_location"]
     number_retries = 5
-    for current_retry in range(number_retries):
-        response = await client.put(
-            presigned_put, data=json.dumps(all_data[el["filepath"]])
-        )
-        if response.status_code < 300:
-            return {
-                "status_code": response.status_code,
-                "filepath": el["filepath"],
-                "succeeded": True,
-            }
-        if response.status_code in retryable_statuses:
-            await asyncio.sleep(2**current_retry)
+    try:
+        for current_retry in range(number_retries):
+            response = await client.put(
+                presigned_put, data=json.dumps(all_data[el["filepath"]])
+            )
+            if response.status_code < 300:
+                return {
+                    "status_code": response.status_code,
+                    "filepath": el["filepath"],
+                    "succeeded": True,
+                }
+            if response.status_code in retryable_statuses:
+                await asyncio.sleep(2**current_retry)
+        status_code = response.status_code
+        message_to_warn = response.text
+        exception = None
+    except httpx.HTTPError as exp:
+        status_code = None
+        exception = type(exp)
+        message_to_warn = str(exp)
     logger.warning(
-        "Unable to send data",
+        "Unable to send single_upload_put",
         extra=dict(
             extra_log_attributes=dict(
-                response=response.text,
+                message=message_to_warn,
+                exception=exception,
                 filepath=el["filepath"],
-                url=presigned_put,
-                latest_status_code=response.status_code,
+                latest_status_code=status_code,
             )
         ),
     )
     return {
-        "status_code": response.status_code,
+        "status_code": status_code,
+        "exception": exception,
         "filepath": el["filepath"],
         "succeeded": False,
     }
@@ -205,7 +257,9 @@ def send_finish_signal(response_json, upload_url: str, token: str):
     return response
 
 
-def analyze_file(config, filename: FileAnalysisRequest):
+def analyze_file(
+    config, filename: FileAnalysisRequest
+) -> typing.Optional[FileAnalysisResult]:
     try:
         with open(filename.actual_filepath, "rb") as file:
             actual_code = file.read()
@@ -219,7 +273,7 @@ def analyze_file(config, filename: FileAnalysisRequest):
     except AnalysisError as e:
         error_dict = {
             "filename": str(filename.result_filename),
-            "error_class": str(type(e)),
+            "error": str(e),
         }
         return FileAnalysisResult(
             filename=str(filename.result_filename), error=error_dict

{codecov-cli-0.3.2 → codecov-cli-0.3.4}/codecov_cli/services/staticanalysis/analyzers/__init__.py

@@ -1,9 +1,12 @@
 from codecov_cli.services.staticanalysis.analyzers.general import BaseAnalyzer
 from codecov_cli.services.staticanalysis.analyzers.javascript_es6 import ES6Analyzer
 from codecov_cli.services.staticanalysis.analyzers.python import PythonAnalyzer
+from codecov_cli.services.staticanalysis.types import FileAnalysisRequest
 
 
-def get_best_analyzer(filename, actual_code) -> BaseAnalyzer:
+def get_best_analyzer(
+    filename: FileAnalysisRequest, actual_code: bytes
+) -> BaseAnalyzer:
     if filename.actual_filepath.suffix == ".py":
         return PythonAnalyzer(filename, actual_code)
     if filename.actual_filepath.suffix == ".js":

{codecov-cli-0.3.2 → codecov-cli-0.3.4}/codecov_cli/services/staticanalysis/analyzers/python/__init__.py

@@ -7,6 +7,7 @@ from codecov_cli.services.staticanalysis.analyzers.general import BaseAnalyzer
 from codecov_cli.services.staticanalysis.analyzers.python.node_wrappers import (
     NodeVisitor,
 )
+from codecov_cli.services.staticanalysis.types import FileAnalysisRequest
 
 _function_query_str = """
 (function_definition
@@ -52,14 +53,16 @@ class PythonAnalyzer(BaseAnalyzer):
     ]
     wrappers = ["class_definition", "function_definition"]
 
-    def __init__(self, path, actual_code, **options):
+    def __init__(
+        self, file_analysis_request: FileAnalysisRequest, actual_code: bytes, **options
+    ):
         self.actual_code = actual_code
         self.lines = self.actual_code.split(b"\n")
         self.statements = []
         self.import_lines = set()
         self.definitions_lines = set()
         self.functions = []
-        self.path = path.result_filename
+        self.path = file_analysis_request.result_filename
         self.PY_LANGUAGE = Language(staticcodecov_languages.__file__, "python")
         self.parser = Parser()
         self.parser.set_language(self.PY_LANGUAGE)

codecov-cli-0.3.4/codecov_cli/services/staticanalysis/analyzers/python/node_wrappers.py

@@ -0,0 +1,117 @@
+from tree_sitter import Node
+
+from codecov_cli.services.staticanalysis.exceptions import AnalysisError
+
+
+class NodeVisitor(object):
+    def __init__(self, analyzer):
+        self.analyzer = analyzer
+
+    def start_visit(self, node):
+        self.visit(node)
+
+    def visit(self, node: Node):
+        self.do_visit(node)
+        for c in node.children:
+            self.visit(c)
+
+    def _is_function_docstring(self, node: Node):
+        """Skips docstrings for funtions, such as this one.
+        Pytest doesn't include them in the report, so I don't think we should either,
+        at least for now.
+        """
+        # Docstrings have type 'expression_statement
+        if node.type != "expression_statement":
+            return False
+        # Docstrings for a module are OK - they show up in pytest result
+        # Docstrings for a class are OK - they show up in pytest result
+        # Docstrings for functions are NOT OK - they DONT show up in pytest result
+        # Check if it's docstring
+        has_single_child = len(node.children) == 1
+        only_child_is_string = node.children[0].type == "string"
+        # Check if is the first line of a function
+        parent_is_block = node.parent.type == "block"
+        first_exp_in_block = node.prev_named_sibling is None
+        is_in_function_context = (
+            parent_is_block and node.parent.parent.type == "function_definition"
+        )
+
+        return (
+            has_single_child
+            and only_child_is_string
+            and parent_is_block
+            and first_exp_in_block
+            and is_in_function_context
+        )
+
+    def _get_previous_sibling_that_is_not_comment_not_func_docstring(self, node: Node):
+        curr = node.prev_named_sibling
+        while curr is not None and (
+            curr.type == "comment" or self._is_function_docstring(curr)
+        ):
+            curr = curr.prev_named_sibling
+        return curr
+
+    def do_visit(self, node: Node):
+        if node.is_named:
+            current_line_number = node.start_point[0] + 1
+            if node.type in (
+                "expression_statement",
+                "return_statement",
+                "if_statement",
+                "for_statement",
+                "while_statement",
+            ):
+                if self._is_function_docstring(node):
+                    # We ignore these
+                    return
+                closest_named_sibling_not_comment_that_is_in_statements = (
+                    self._get_previous_sibling_that_is_not_comment_not_func_docstring(
+                        node
+                    )
+                )
+                if closest_named_sibling_not_comment_that_is_in_statements:
+                    self.analyzer.line_surety_ancestorship[current_line_number] = (
+                        closest_named_sibling_not_comment_that_is_in_statements.start_point[
+                            0
+                        ]
+                        + 1
+                    )
+                self.analyzer.statements.append(
+                    {
+                        "current_line": current_line_number,
+                        "start_column": node.start_point[1],
+                        "line_hash": self.analyzer._get_code_hash(
+                            node.start_byte, node.end_byte
+                        ),
+                        "len": node.end_point[0] + 1 - current_line_number,
+                        "extra_connected_lines": tuple(),
+                    }
+                )
+            if node.type in ("if_statement", "elif_clause"):
+                # Some of the children of a node have a field_name associated to them
+                # In the case of an if and elif, "consequence" is the code that is executed in that branch of code
+                first_if_statement = node.child_by_field_name("consequence")
+                try:
+                    if first_if_statement.type == "block":
+                        first_if_statement = first_if_statement.children[0]  # BUG
+                except IndexError:
+                    raise AnalysisError(
+                        f"if_statement consequence is empty block @ {self.analyzer.path}:{first_if_statement.start_point[0] + 1}, column {first_if_statement.start_point[1]}"
+                    )
+                self.analyzer.line_surety_ancestorship[
+                    first_if_statement.start_point[0] + 1
+                ] = current_line_number
+            if node.type in ("for_statement", "while_statement"):
+                first_loop_statement = node.child_by_field_name("body")
+                try:
+                    if first_loop_statement.type == "block":
+                        first_loop_statement = first_loop_statement.children[0]
+                except IndexError:
+                    raise AnalysisError(
+                        f"loop_statement body is empty block @ {self.analyzer.path}:{first_loop_statement.start_point[0] + 1}, column {first_loop_statement.start_point[1]}"
+                    )
+                self.analyzer.line_surety_ancestorship[
+                    first_loop_statement.start_point[0] + 1
+                ] = current_line_number
+                pass

{codecov-cli-0.3.2 → codecov-cli-0.3.4}/codecov_cli/services/upload/__init__.py

@@ -50,6 +50,7 @@ def do_upload_logic(
     enterprise_url: typing.Optional[str],
     disable_search: bool = False,
     handle_no_reports_found: bool = False,
+    disable_file_fixes: bool = False,
 ):
     preparation_plugins = select_preparation_plugins(cli_config, plugin_names)
     coverage_file_selector = select_coverage_file_finder(
@@ -60,7 +61,7 @@ def do_upload_logic(
     )
     network_finder = select_network_finder(versioning_system)
     collector = UploadCollector(
-        preparation_plugins, network_finder, coverage_file_selector
+        preparation_plugins, network_finder, coverage_file_selector, disable_file_fixes
     )
     try:
         upload_data = collector.generate_upload_data()

{codecov-cli-0.3.2 → codecov-cli-0.3.4}/codecov_cli/services/upload/upload_collector.py

@@ -29,15 +29,17 @@ class UploadCollector(object):
         preparation_plugins: typing.List[PreparationPluginInterface],
         network_finder: NetworkFinder,
         coverage_file_finder: CoverageFileFinder,
+        disable_file_fixes: bool = False,
     ):
         self.preparation_plugins = preparation_plugins
         self.network_finder = network_finder
         self.coverage_file_finder = coverage_file_finder
+        self.disable_file_fixes = disable_file_fixes
 
     def _produce_file_fixes_for_network(
         self, network: typing.List[str]
     ) -> typing.List[UploadCollectionResultFileFixer]:
-        if not network:
+        if not network or self.disable_file_fixes:
             return []
         # patterns that we don't need to specify a reason for
         empty_line_regex = re.compile(r"^\s*$")

{codecov-cli-0.3.2 → codecov-cli-0.3.4/codecov_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: codecov-cli
-Version: 0.3.2
+Version: 0.3.4
 Summary: Codecov Command Line Interface
 Author: Codecov
 Author-email: support@codecov.io

{codecov-cli-0.3.2 → codecov-cli-0.3.4}/codecov_cli.egg-info/requires.txt

@@ -1,8 +1,6 @@
 click==8.*
 httpx==0.23.*
 ijson==3.*
-pytest==7.*
-pytest-cov>=3
 pyyaml==6.*
 responses==0.21.*
 smart-open==6.*

{codecov-cli-0.3.2 → codecov-cli-0.3.4}/setup.py

@@ -8,8 +8,8 @@ here = path.abspath(path.dirname(__file__))
 with open(path.join(here, "README.md"), encoding="utf-8") as f:
     long_description = f.read()
 
-with open(path.join(here, "codecov_cli/__init__.py"), encoding="utf-8") as f:
-    version = f.read().split('"')[1]
+with open(path.join(here, "VERSION"), encoding="utf-8") as f:
+    version = f.readline().strip()
 
 setup(
     name="codecov-cli",
@@ -24,8 +24,6 @@ setup(
         "click==8.*",
         "httpx==0.23.*",
         "ijson==3.*",
-        "pytest==7.*",
-        "pytest-cov>=3",
         "pyyaml==6.*",
         "responses==0.21.*",
         "smart-open==6.*",

codecov-cli-0.3.2/codecov_cli/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.3.2"

codecov-cli-0.3.2/codecov_cli/services/staticanalysis/analyzers/python/node_wrappers.py

@@ -1,52 +0,0 @@
-class NodeVisitor(object):
-    def __init__(self, analyzer):
-        self.analyzer = analyzer
-
-    def start_visit(self, node):
-        self.visit(node)
-
-    def visit(self, node):
-        self.do_visit(node)
-        for c in node.children:
-            self.visit(c)
-
-    def do_visit(self, node):
-        if node.is_named:
-            current_line_number = node.start_point[0] + 1
-            if node.type in (
-                "expression_statement",
-                "return_statement",
-                "if_statement",
-                "for_statement",
-                "while_statement",
-            ):
-                if node.prev_named_sibling:
-                    self.analyzer.line_surety_ancestorship[current_line_number] = (
-                        node.prev_named_sibling.start_point[0] + 1
-                    )
-                self.analyzer.statements.append(
-                    {
-                        "current_line": current_line_number,
-                        "start_column": node.start_point[1],
-                        "line_hash": self.analyzer._get_code_hash(
-                            node.start_byte, node.end_byte
-                        ),
-                        "len": node.end_point[0] + 1 - current_line_number,
-                        "extra_connected_lines": tuple(),
-                    }
-                )
-            if node.type in ("if_statement", "elif_clause"):
-                first_if_statement = node.child_by_field_name("consequence")
-                if first_if_statement.type == "block":
-                    first_if_statement = first_if_statement.children[0]
-                self.analyzer.line_surety_ancestorship[
-                    first_if_statement.start_point[0] + 1
-                ] = current_line_number
-            if node.type in ("for_statement", "while_statement"):
-                first_if_statement = node.child_by_field_name("body")
-                if first_if_statement.type == "block":
-                    first_if_statement = first_if_statement.children[0]
-                self.analyzer.line_surety_ancestorship[
-                    first_if_statement.start_point[0] + 1
-                ] = current_line_number
-                pass