codecov-cli 11.0.0__py3-none-any.whl

codecov_cli/helpers/git.py

@@ -0,0 +1,97 @@
+import logging
+import re
+from enum import Enum
+from typing import Optional
+from urllib.parse import urlparse
+
+from codecov_cli.helpers.encoder import decode_slug
+from codecov_cli.helpers.git_services import PullDict
+from codecov_cli.helpers.git_services.github import Github
+
+slug_regex = re.compile(r"[^/\s]+\/[^/\s]+$")
+
+logger = logging.getLogger("codecovcli")
+
+
+class GitService(Enum):
+    GITHUB = "github"
+    GITLAB = "gitlab"
+    BITBUCKET = "bitbucket"
+    GITHUB_ENTERPRISE = "github_enterprise"
+    GITLAB_ENTERPRISE = "gitlab_enterprise"
+    BITBUCKET_SERVER = "bitbucket_server"
+
+
+def get_git_service(git):
+    if git == "github":
+        return Github()
+
+
+def parse_slug(remote_repo_url: str):
+    """
+    Extracts a slug from git remote urls. returns None if the url is invalid
+
+    Examples:
+    - https://github.com/codecov/codecov-cli.git returns codecov/codecov-cli
+    - git@github.com:codecov/codecov-cli.git returns codecov/codecov-cli
+    """
+    parsed_url = urlparse(remote_repo_url)
+
+    path_to_parse = parsed_url.path
+
+    if path_to_parse.endswith("/"):
+        path_to_parse = path_to_parse.rsplit("/", 1)[0]
+    if path_to_parse.endswith(".git"):
+        path_to_parse = path_to_parse.rsplit(".git", 1)[0]
+    if ":" in path_to_parse:
+        path_to_parse = path_to_parse.split(":", 1)[1]
+    if path_to_parse.startswith("/"):
+        path_to_parse = path_to_parse[1:]
+
+    if not slug_regex.match(path_to_parse):
+        return None
+
+    return path_to_parse
+
+
+def parse_git_service(remote_repo_url: str):
+    """
+    Extracts git service from git remote urls. returns None if the url is invalid
+
+    Possible cases we're considering:
+    - https://github.com/codecov/codecov-cli.git returns github
+    - git@github.com:codecov/codecov-cli.git returns github
+    - ssh://git@github.com/gitcodecov/codecov-cli returns github
+    - ssh://git@github.com:gitcodecov/codecov-cli returns github
+    - https://user-name@bitbucket.org/namespace-codecov/first_repo.git returns bitbucket
+    """
+    services = [service.value for service in GitService]
+    parsed_url = urlparse(remote_repo_url)
+    service = None
+
+    scheme = parsed_url.scheme
+    if scheme in ("https", "ssh"):
+        netloc = parsed_url.netloc
+        if "@" in netloc:
+            netloc = netloc.split("@", 1)[1]
+        if "." in netloc:
+            netloc = netloc.split(".", 1)[0]
+        service = netloc
+    elif remote_repo_url.startswith("git@"):
+        path = parsed_url.path
+        if "@" in path:
+            path = path.split("@", 1)[1]
+        if ":" in path:
+            path = path.split(":", 1)[0]
+        if "." in path:
+            path = path.split(".", 1)[0]
+        service = path
+
+    if service in services:
+        return service
+    else:
+        logger.warning(
+            f"Service not found: {service}. Possible services are {services}",
+            extra=dict(remote_repo_url=remote_repo_url),
+        )
+        return None

codecov_cli/helpers/git_services/__init__.py

@@ -0,0 +1,14 @@
+from typing import TypedDict
+
+
+class CommitInfo(TypedDict):
+    sha: str
+    label: str
+    ref: str
+    slug: str
+
+
+class PullDict(TypedDict):
+    url: str
+    head: CommitInfo
+    base: CommitInfo

codecov_cli/helpers/git_services/github.py

@@ -0,0 +1,40 @@
+import json
+
+import requests
+
+from codecov_cli.helpers.git_services import PullDict
+
+
+class Github:
+    api_url = "https://api.github.com"
+    api_version = "2022-11-28"
+
+    def get_pull_request(self, slug, pr_number) -> PullDict:
+        pull_url = f"/repos/{slug}/pulls/{pr_number}"
+        url = self.api_url + pull_url
+        headers = {"X-GitHub-Api-Version": self.api_version}
+        response = requests.get(url, headers=headers)
+        if response.status_code == 200:
+            res = json.loads(response.text)
+            return {
+                "url": res["url"],
+                "head": {
+                    "sha": res["head"]["sha"],
+                    "label": res["head"]["label"],
+                    "ref": res["head"]["ref"],
+                    # Through empiric test data it seems that the "repo" key in "head" is set to None
+                    # If the PR is from the same repo (e.g. not from a fork)
+                    "slug": (
+                        res["head"]["repo"]["full_name"]
+                        if res["head"]["repo"]
+                        else res["base"]["repo"]["full_name"]
+                    ),
+                },
+                "base": {
+                    "sha": res["base"]["sha"],
+                    "label": res["base"]["label"],
+                    "ref": res["base"]["ref"],
+                    "slug": res["base"]["repo"]["full_name"],
+                },
+            }
+        return None

codecov_cli/helpers/glob.py

@@ -0,0 +1,146 @@
+"""
+This is a copy of the function of the same name in the python
+standard library. The reason for its inclusion is that it has
+been added in python3.13, but not earlier versions
+https://github.com/python/cpython/blob/main/Lib/glob.py
+https://github.com/python/cpython/blob/main/Lib/fnmatch.py
+https://github.com/python/cpython/blob/main/Lib/functools.py
+"""
+
+import os
+import re
+
+from glob import fnmatch
+
+
+def translate(pat, *, recursive=False, include_hidden=False, seps=None):
+    """Translate a pathname with shell wildcards to a regular expression.
+
+    If `recursive` is true, the pattern segment '**' will match any number of
+    path segments.
+
+    If `include_hidden` is true, wildcards can match path segments beginning
+    with a dot ('.').
+
+    If a sequence of separator characters is given to `seps`, they will be
+    used to split the pattern into segments and match path separators. If not
+    given, os.path.sep and os.path.altsep (where available) are used.
+    """
+    if not seps:
+        if os.path.altsep:
+            seps = (os.path.sep, os.path.altsep)
+        else:
+            seps = os.path.sep
+    escaped_seps = ''.join(map(re.escape, seps))
+    any_sep = f'[{escaped_seps}]' if len(seps) > 1 else escaped_seps
+    not_sep = f'[^{escaped_seps}]'
+    if include_hidden:
+        one_last_segment = f'{not_sep}+'
+        one_segment = f'{one_last_segment}{any_sep}'
+        any_segments = f'(?:.+{any_sep})?'
+        any_last_segments = '.*'
+    else:
+        one_last_segment = f'[^{escaped_seps}.]{not_sep}*'
+        one_segment = f'{one_last_segment}{any_sep}'
+        any_segments = f'(?:{one_segment})*'
+        any_last_segments = f'{any_segments}(?:{one_last_segment})?'
+
+    results = []
+    parts = re.split(any_sep, pat)
+    last_part_idx = len(parts) - 1
+    for idx, part in enumerate(parts):
+        if part == '*':
+            results.append(one_segment if idx < last_part_idx else one_last_segment)
+        elif recursive and part == '**':
+            if idx < last_part_idx:
+                if parts[idx + 1] != '**':
+                    results.append(any_segments)
+            else:
+                results.append(any_last_segments)
+        else:
+            if part:
+                if not include_hidden and part[0] in '*?':
+                    results.append(r'(?!\.)')
+                results.extend(_translate(part, f'{not_sep}*', not_sep)[0])
+            if idx < last_part_idx:
+                results.append(any_sep)
+    res = ''.join(results)
+    return fr'(?s:{res})\Z'
+
+
+_re_setops_sub = re.compile(r'([&~|])').sub
+def _translate(pat, star, question_mark):
+    res = []
+    add = res.append
+    star_indices = []
+
+    i, n = 0, len(pat)
+    while i < n:
+        c = pat[i]
+        i = i+1
+        if c == '*':
+            # store the position of the wildcard
+            star_indices.append(len(res))
+            add(star)
+            # compress consecutive `*` into one
+            while i < n and pat[i] == '*':
+                i += 1
+        elif c == '?':
+            add(question_mark)
+        elif c == '[':
+            j = i
+            if j < n and pat[j] == '!':
+                j = j+1
+            if j < n and pat[j] == ']':
+                j = j+1
+            while j < n and pat[j] != ']':
+                j = j+1
+            if j >= n:
+                add('\\[')
+            else:
+                stuff = pat[i:j]
+                if '-' not in stuff:
+                    stuff = stuff.replace('\\', r'\\')
+                else:
+                    chunks = []
+                    k = i+2 if pat[i] == '!' else i+1
+                    while True:
+                        k = pat.find('-', k, j)
+                        if k < 0:
+                            break
+                        chunks.append(pat[i:k])
+                        i = k+1
+                        k = k+3
+                    chunk = pat[i:j]
+                    if chunk:
+                        chunks.append(chunk)
+                    else:
+                        chunks[-1] += '-'
+                    # Remove empty ranges -- invalid in RE.
+                    for k in range(len(chunks)-1, 0, -1):
+                        if chunks[k-1][-1] > chunks[k][0]:
+                            chunks[k-1] = chunks[k-1][:-1] + chunks[k][1:]
+                            del chunks[k]
+                    # Escape backslashes and hyphens for set difference (--).
+                    # Hyphens that create ranges shouldn't be escaped.
+                    stuff = '-'.join(s.replace('\\', r'\\').replace('-', r'\-')
+                                     for s in chunks)
+                i = j+1
+                if not stuff:
+                    # Empty range: never match.
+                    add('(?!)')
+                elif stuff == '!':
+                    # Negated empty range: match any character.
+                    add('.')
+                else:
+                    # Escape set operations (&&, ~~ and ||).
+                    stuff = _re_setops_sub(r'\\\1', stuff)
+                    if stuff[0] == '!':
+                        stuff = '^' + stuff[1:]
+                    elif stuff[0] in ('^', '['):
+                        stuff = '\\' + stuff
+                    add(f'[{stuff}]')
+        else:
+            add(re.escape(c))
+    assert i == n
+    return res, star_indices

codecov_cli/helpers/logging_utils.py

@@ -0,0 +1,77 @@
+import json
+import logging
+
+import click
+
+# Heavily inspired on https://github.com/click-contrib/click-log/blob/master/click_log/core.py
+
+
+class JsonEncoder(json.JSONEncoder):
+    """
+    A custom encoder extending the default JSONEncoder
+    """
+
+    def default(self, obj):
+        try:
+            return super(JsonEncoder, self).default(obj)
+        except TypeError:
+            try:
+                return str(obj)
+            except Exception:
+                return None
+
+
+class ColorFormatter(logging.Formatter):
+    colors = {
+        "error": dict(fg="red"),
+        "exception": dict(fg="red"),
+        "critical": dict(fg="red"),
+        "debug": dict(fg="blue"),
+        "warning": dict(fg="yellow"),
+        "info": dict(fg="blue"),
+    }
+
+    def format(self, record):
+        if not record.exc_info:
+            level = record.levelname.lower()
+            asctime = self.formatTime(record, self.datefmt)
+            msg = record.getMessage()
+            if level in self.colors:
+                prefix = click.style("{}".format(level), **self.colors[level])
+                msg = "\n".join(
+                    f"{prefix} - {asctime} -- {x}" for x in msg.splitlines()
+                )
+            if hasattr(record, "extra_log_attributes"):
+                token = record.extra_log_attributes.get("token")
+                if token:
+                    record.extra_log_attributes["token"] = (
+                        "NOTOKEN" if not token else (str(token)[:1] + 18 * "*")
+                    )
+                msg += " --- " + json.dumps(
+                    record.extra_log_attributes, cls=JsonEncoder
+                )
+            return msg
+        return super().format(record)
+
+
+class ClickHandler(logging.Handler):
+    _use_stderr = True
+    formatter = ColorFormatter()
+
+    def emit(self, record):
+        try:
+            msg = self.format(record)
+            click.echo(msg, err=self._use_stderr)
+        except Exception:
+            self.handleError(record)
+
+
+def configure_logger(logger: logging.Logger, log_level=logging.INFO):
+    # This if exists to avoid an issue where extra handlers would be added by tests that use runner.invoke()
+    # Which would cause subsequent tests to failed due to repeated log lines
+    if not logger.hasHandlers():
+        ch = ClickHandler()
+        ch.setFormatter(ColorFormatter())
+        logger.addHandler(ch)
+    logger.propagate = False
+    logger.setLevel(log_level)

codecov_cli/helpers/options.py

@@ -0,0 +1,51 @@
+import click
+
+from codecov_cli.fallbacks import CodecovOption, FallbackFieldEnum
+from codecov_cli.helpers.git import GitService
+
+_global_options = [
+    click.option(
+        "-C",
+        "--sha",
+        "--commit-sha",
+        "commit_sha",
+        help="Commit SHA (with 40 chars)",
+        cls=CodecovOption,
+        fallback_field=FallbackFieldEnum.commit_sha,
+        required=True,
+    ),
+    click.option(
+        "-Z",
+        "--fail-on-error",
+        "fail_on_error",
+        is_flag=True,
+        help="Exit with non-zero code in case of error",
+    ),
+    click.option(
+        "--git-service",
+        cls=CodecovOption,
+        fallback_field=FallbackFieldEnum.git_service,
+        type=click.Choice([service.value for service in GitService]),
+    ),
+    click.option(
+        "-t",
+        "--token",
+        help="Codecov upload token",
+        envvar="CODECOV_TOKEN",
+    ),
+    click.option(
+        "-r",
+        "--slug",
+        "slug",
+        cls=CodecovOption,
+        fallback_field=FallbackFieldEnum.slug,
+        help="owner/repo slug used instead of the private repo token in Self-hosted",
+        envvar="CODECOV_SLUG",
+    ),
+]
+
+
+def global_options(func):
+    for option in reversed(_global_options):
+        func = option(func)
+    return func

codecov_cli/helpers/request.py

@@ -0,0 +1,198 @@
+import json
+import logging
+from sys import exit
+from time import sleep
+from typing import Optional
+
+import click
+import requests
+
+from codecov_cli import __version__
+from codecov_cli.types import RequestError, RequestResult
+
+logger = logging.getLogger("codecovcli")
+
+MAX_RETRIES = 3
+
+USER_AGENT = f"codecov-cli/{__version__}"
+
+
+def _set_user_agent(headers: Optional[dict] = None) -> dict:
+    headers = headers or {}
+    headers.setdefault("User-Agent", USER_AGENT)
+    return headers
+
+
+def patch(url: str, headers: dict = None, json: dict = None) -> requests.Response:
+    headers = _set_user_agent(headers)
+    return requests.patch(url, json=json, headers=headers)
+
+
+def get(url: str, headers: dict = None, params: dict = None) -> requests.Response:
+    headers = _set_user_agent(headers)
+    return requests.get(url, params=params, headers=headers)
+
+
+def put(url: str, data: dict = None, headers: dict = None) -> requests.Response:
+    headers = _set_user_agent(headers)
+    return requests.put(url, data=data, headers=headers)
+
+
+def post(
+    url: str,
+    data: Optional[dict] = None,
+    headers: Optional[dict] = None,
+    params: Optional[dict] = None,
+) -> requests.Response:
+    headers = _set_user_agent(headers)
+    return requests.post(url, json=data, headers=headers, params=params)
+
+
+def backoff_time(curr_retry):
+    return 2 ** (curr_retry - 1)
+
+
+class RetryException(Exception): ...
+
+
+def retry_request(func):
+    def wrapper(*args, **kwargs):
+        retry = 0
+        while retry < MAX_RETRIES:
+            try:
+                response = func(*args, **kwargs)
+                if response.status_code >= 500:
+                    logger.warning(
+                        f"Response status code was {response.status_code}.",
+                        extra=dict(extra_log_attributes=dict(retry=retry)),
+                    )
+                    raise RetryException
+                return response
+            except (
+                requests.exceptions.ConnectionError,
+                requests.exceptions.Timeout,
+                RetryException,
+            ):
+                logger.warning(
+                    "Request failed. Retrying",
+                    extra=dict(extra_log_attributes=dict(retry=retry)),
+                )
+                sleep(backoff_time(retry))
+                retry += 1
+        raise Exception(f"Request failed after too many retries. URL: {kwargs.get('url', args[0] if args else 'Unknown')}")
+
+    return wrapper
+
+
+@retry_request
+def send_post_request(
+    url: str,
+    data: Optional[dict] = None,
+    headers: Optional[dict] = None,
+    params: Optional[dict] = None,
+):
+    return request_result(post(url=url, data=data, headers=headers, params=params))
+
+
+@retry_request
+def send_get_request(
+    url: str, headers: dict = None, params: dict = None
+) -> RequestResult:
+    return request_result(get(url=url, headers=headers, params=params))
+
+
+def get_token_header_or_fail(token: Optional[str]) -> dict:
+    """
+    Rejects requests with no Authorization token. Prevents tokenless uploads.
+    """
+    if token is None:
+        raise click.ClickException(
+            "Codecov token not found. Please provide Codecov token with -t flag."
+        )
+    return {"Authorization": f"token {token}"}
+
+
+def get_token_header(token: Optional[str]) -> Optional[dict]:
+    """
+    Allows requests with no Authorization token.
+    """
+    if token is None:
+        return None
+    return {"Authorization": f"token {token}"}
+
+
+@retry_request
+def send_put_request(
+    url: str,
+    data: dict = None,
+    headers: dict = None,
+):
+    return request_result(put(url=url, data=data, headers=headers))
+
+
+def request_result(resp: requests.Response) -> RequestResult:
+    if resp.status_code >= 400:
+        return RequestResult(
+            status_code=resp.status_code,
+            error=RequestError(
+                code=f"HTTP Error {resp.status_code}",
+                description=resp.text,
+                params={},
+            ),
+            warnings=[],
+            text=resp.text,
+        )
+
+    return RequestResult(
+        status_code=resp.status_code, error=None, warnings=[], text=resp.text
+    )
+
+
+def log_warnings_and_errors_if_any(
+    sending_result: RequestResult, process_desc: str, fail_on_error: bool = False
+):
+    logger.info(
+        f"Process {process_desc} complete",
+    )
+    logger.debug(
+        f"{process_desc} result",
+        extra=dict(
+            extra_log_attributes=dict(result=_sanitize_request_result(sending_result))
+        ),
+    )
+    if sending_result.warnings:
+        number_warnings = len(sending_result.warnings)
+        pluralization = "s" if number_warnings > 1 else ""
+        logger.info(
+            f"{process_desc} process had {number_warnings} warning{pluralization}",
+        )
+        for ind, w in enumerate(sending_result.warnings):
+            logger.warning(f"Warning {ind + 1}: {w.message}")
+    if sending_result.error is not None:
+        logger.error(f"{process_desc} failed: {sending_result.error.description}")
+        if fail_on_error:
+            exit(1)
+
+
+def _sanitize_request_result(result: RequestResult):
+    if not hasattr(result, "text"):
+        return result
+
+    try:
+        text_as_dict = json.loads(result.text)
+        token = text_as_dict.get("repository").get("yaml").get("codecov").get("token")
+        if token:
+            sanitized_token = str(token)[:1] + 18 * "*"
+            text_as_dict["repository"]["yaml"]["codecov"]["token"] = sanitized_token
+            sanitized_text = json.dumps(text_as_dict)
+
+            return RequestResult(
+                status_code=result.status_code,
+                error=result.error,
+                warnings=result.warnings,
+                text=sanitized_text,
+            )
+    except (AttributeError, json.JSONDecodeError):
+        pass
+
+    return result

codecov_cli/helpers/upload_type.py

@@ -0,0 +1,15 @@
+from enum import Enum
+
+
+class ReportType(Enum):
+    COVERAGE = "coverage"
+    TEST_RESULTS = "test_results"
+
+
+def report_type_from_str(report_type_str: str) -> ReportType:
+    if report_type_str == "coverage":
+        return ReportType.COVERAGE
+    elif report_type_str == "test_results":
+        return ReportType.TEST_RESULTS
+    else:
+        raise ValueError(f"Invalid upload type: {report_type_str}")

codecov_cli/helpers/validators.py

@@ -0,0 +1,13 @@
+import re
+
+import click
+
+
+def validate_commit_sha(ctx, param, value):
+    if value == "" or value is None:
+        raise click.MissingParameter()
+    if len(value) < 40:
+        raise click.BadParameter("Use the full commit SHA")
+    if not re.match(r"[0-9a-f]{40}", value):
+        raise click.BadParameter("Commit SHA doesn't match SHA1 regex")
+    return value