quickpub 4.1.4__py3-none-any.whl

quickpub/strategies/implementations/quality_assurance_runners/pylint_qa_runner.py

@@ -0,0 +1,106 @@
+import logging
+import re
+from typing import Optional, List
+
+from danielutils import LayeredCommand
+
+from ....enforcers import ExitEarlyError
+from ...quality_assurance_runner import QualityAssuranceRunner
+
+logger = logging.getLogger(__name__)
+
+
+class PylintRunner(QualityAssuranceRunner):
+    """Quality assurance runner for pylint code analysis. Scores based on pylint rating (0.0 to 10.0)."""
+
+    def _install_dependencies(self, base: LayeredCommand) -> None:
+        logger.info("Installing pylint dependencies")
+        with base:
+            base(self.package_manager.install_command("pylint"))
+
+    RATING_PATTERN: re.Pattern = re.compile(r"([\d.]+)/([\d.]+)")
+
+    def __init__(
+        self,
+        bound: str = ">=0.8",
+        configuration_path: Optional[str] = None,
+        executable_path: Optional[str] = None,
+        package_manager=None,
+    ) -> None:
+        QualityAssuranceRunner.__init__(
+            self,
+            name="pylint",
+            bound=bound,
+            configuration_path=configuration_path,
+            executable_path=executable_path,
+            package_manager=package_manager,
+        )
+        logger.info(
+            "Initialized PylintRunner with bound='%s', config='%s', executable='%s'",
+            bound,
+            configuration_path,
+            executable_path,
+        )
+
+    def _build_command(self, target: str, use_system_interpreter: bool = False) -> str:
+        command: str = self.get_executable()
+        if self.has_config:
+            command += f" --rcfile {self.config_path}"
+        command += f" {target}"
+        return command
+
+    def _calculate_score(
+        self, ret: int, lines: List[str], verbose: bool = False
+    ) -> float:
+        logger.debug("Calculating pylint score from analysis results")
+
+        if len(lines) == 0:
+            logger.debug("No pylint output, returning perfect score: 1.0")
+            return 1
+
+        for line in reversed(lines):
+            match = self.RATING_PATTERN.search(line)
+            if match:
+                numerator = float(match.group(1))
+                denominator = float(match.group(2))
+                score = numerator / denominator
+                logger.debug(
+                    "Pylint score calculated: %.3f (%s/%s)",
+                    score,
+                    match.group(1),
+                    match.group(2),
+                )
+                return score
+
+        if ret == 0:
+            return 1.0
+
+        joined_output = "\n".join(lines)
+        if ret == 1 and "parse-error" in joined_output:
+            logger.debug(
+                "Pylint reported parse-error with an empty target, returning perfect score: 1.0"
+            )
+            return 1.0
+
+        if len(lines) == 1:
+            if lines[0].endswith("No module named pylint"):
+                logger.error("Pylint module not found")
+                raise ExitEarlyError("No module named pylint found")
+
+            if lines[0].startswith("The config file") and lines[0].endswith(
+                "doesn't exist!"
+            ):
+                logger.error("Config file error: %s", lines[0])
+                raise ExitEarlyError(lines[0])
+
+            logger.error("Unexpected pylint error: %s", lines[0])
+            raise ExitEarlyError(f"Got an unexpected error: {lines[0]}")
+
+        msg = f"Failed running Pylint, got exit code {ret}. Try running manually using: {self._build_command('TARGET')}"
+        logger.error("Failed to parse pylint rating from output: %s", joined_output)
+        raise ExitEarlyError(msg)
+
+
+__all__ = [
+    "PylintRunner",
+]

quickpub/strategies/implementations/quality_assurance_runners/pytest_qa_runner.py

@@ -0,0 +1,188 @@
+import logging
+import re
+import subprocess
+import sys
+from typing import List, Union, Literal, Optional
+
+from danielutils import LayeredCommand
+
+from ....enforcers import ExitEarlyError
+from ....structures import Bound
+from ...quality_assurance_runner import QualityAssuranceRunner
+
+logger = logging.getLogger(__name__)
+
+
+class PytestRunner(QualityAssuranceRunner):
+    """Quality assurance runner for pytest testing. Scores based on the ratio of passed tests to total tests."""
+
+    PYTEST_SUMMARY_REGEX: re.Pattern = re.compile(
+        r"=+ .*?in [\d\.]+s(?: \([^)]+\))? =+"
+    )
+    PYTEST_QUIET_SUMMARY_REGEX: re.Pattern = re.compile(
+        r".*\d+ (?:failed|passed).+in [\d\.]+s(?: \([^)]+\))?"
+    )
+    PYTEST_FAILED_REGEX: re.Pattern = re.compile(r"(\d+) failed")
+    PYTEST_PASSED_REGEX: re.Pattern = re.compile(r"(\d+) passed")
+    PYTEST_SKIPPED_REGEX: re.Pattern = re.compile(r"(\d+) skipped")
+    ANSI_ESCAPE_REGEX: re.Pattern = re.compile(r"\x1b\[[0-9;]*m")
+
+    def __init__(
+        self,
+        *,
+        bound: Union[str, Bound] = ">=0.8",
+        target: str = "./tests",
+        no_output_score: float = 0.0,
+        no_tests_score: float = 1.0,
+        xdist_workers: Union[int, Literal["auto"]] = "auto",
+        configuration_path: Optional[str] = None,
+        executable_path: Optional[str] = None,
+        package_manager=None,
+    ) -> None:
+        super().__init__(
+            name="pytest",
+            bound=bound,
+            target=target,
+            configuration_path=configuration_path,
+            executable_path=executable_path,
+            package_manager=package_manager,
+        )
+        if not (0.0 <= no_tests_score <= 1.0):
+            raise RuntimeError(
+                "no_tests_score should be between 0.0 and 1.0 (including both)."
+            )
+        self.no_tests_score = no_tests_score
+
+        if not (0.0 <= no_output_score <= 1.0):
+            raise RuntimeError(
+                "no_output_score should be between 0.0 and 1.0 (including both)."
+            )
+        self.no_output_score = no_output_score
+        if isinstance(xdist_workers, int) and xdist_workers <= 0:
+            raise RuntimeError("xdist_workers must be a positive integer or 'auto'.")
+        if isinstance(xdist_workers, str) and xdist_workers != "auto":
+            raise RuntimeError("xdist_workers must be a positive integer or 'auto'.")
+        self.xdist_workers = xdist_workers
+
+        logger.info(
+            "Initialized PytestRunner with bound='%s', target='%s', no_tests_score=%s, no_output_score=%s",
+            bound,
+            target,
+            no_tests_score,
+            no_output_score,
+        )
+
+    def _is_xdist_installed(self) -> bool:
+        try:
+            result = subprocess.run(
+                self.package_manager.show_command("pytest-xdist"),
+                shell=True,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                check=False,
+            )
+            installed = result.returncode == 0
+            logger.debug(
+                "pytest-xdist availability check returned code %d (installed=%s)",
+                result.returncode,
+                installed,
+            )
+            return installed
+        except Exception as exc:  # pragma: no cover - defensive
+            logger.debug("pytest-xdist availability check failed: %s", exc)
+            return False
+
+    def _build_command(self, target: str, use_system_interpreter: bool = False) -> str:
+        base_command = f"{sys.executable} -m pytest"
+        if self.has_config:
+            base_command += f" -c {self.config_path}"
+        if self._is_xdist_installed():
+            logger.debug("pytest-xdist detected; enabling distributed execution")
+            return f"{base_command} -n {self.xdist_workers} {self.target}"
+        logger.debug("pytest-xdist not detected; running without distribution")
+        return f"{base_command} {self.target}"
+
+    def _strip_ansi(self, text: str) -> str:
+        return self.ANSI_ESCAPE_REGEX.sub("", text)
+
+    def _is_summary_line(self, line: str) -> bool:
+        cleaned = self._strip_ansi(line)
+        return bool(
+            self.PYTEST_SUMMARY_REGEX.match(cleaned)
+            or self.PYTEST_QUIET_SUMMARY_REGEX.match(cleaned)
+        )
+
+    def _install_dependencies(self, base: LayeredCommand) -> None:
+        logger.info("Installing pytest dependencies")
+        with base:
+            base(self.package_manager.install_command("pytest"))
+
+    def _calculate_score(
+        self, ret: int, command_output: List[str], *, verbose: bool = False
+    ) -> float:
+        logger.info("Calculating pytest score from test results")
+
+        if len(command_output) == 0:
+            logger.info(
+                "No pytest output, returning no_output_score: %s", self.no_output_score
+            )
+            return self.no_output_score
+
+        # Find the actual summary line by looking for the regex pattern
+        # (pytest output may have warnings or other lines after the summary)
+        rating_line = None
+        for line in reversed(command_output):
+            cleaned_line = self._strip_ansi(line)
+            if "no tests ran" in cleaned_line.lower():
+                logger.info(
+                    "No tests ran, returning no_tests_score: %s", self.no_tests_score
+                )
+                return self.no_tests_score
+            if self._is_summary_line(line):
+                rating_line = cleaned_line
+                break
+
+        if rating_line is None:
+            rating_line = self._strip_ansi(command_output[-1])
+            if "no tests ran" in rating_line.lower():
+                logger.info(
+                    "No tests ran, returning no_tests_score: %s", self.no_tests_score
+                )
+                return self.no_tests_score
+
+        if not (
+            self.PYTEST_SUMMARY_REGEX.match(rating_line)
+            or self.PYTEST_QUIET_SUMMARY_REGEX.match(rating_line)
+        ):
+            logger.error("Failed to parse pytest output: %s", rating_line)
+            raise ExitEarlyError(
+                f"Can't calculate score for pytest on the following line: {rating_line}"
+            )
+
+        failed_match = self.PYTEST_FAILED_REGEX.search(rating_line)
+        passed_match = self.PYTEST_PASSED_REGEX.search(rating_line)
+        skipped_match = self.PYTEST_SKIPPED_REGEX.search(rating_line)
+        failed = int(failed_match.group(1)) if failed_match else 0
+        passed = int(passed_match.group(1)) if passed_match else 0
+        skipped = int(skipped_match.group(1)) if skipped_match else 0
+        assert failed >= 0
+        assert passed >= 0
+        assert skipped >= 0
+
+        total_tests = passed + failed + skipped
+        if total_tests == 0:
+            logger.info(
+                "No test results found, returning no_tests_score: %s",
+                self.no_tests_score,
+            )
+            return self.no_tests_score
+
+        score = passed / total_tests
+        logger.info(
+            "Pytest score calculated: %.3f (passed: %d, failed: %d, skipped: %d)",
+            score,
+            passed,
+            failed,
+            skipped,
+        )
+        return score

quickpub/strategies/implementations/quality_assurance_runners/unittest_qa_runner.py

@@ -0,0 +1,138 @@
+import logging
+import os
+import re
+from pathlib import Path
+from typing import Optional, List, Any
+from danielutils import LayeredCommand
+
+from ....enforcers import ExitEarlyError
+from ...quality_assurance_runner import QualityAssuranceRunner
+
+logger = logging.getLogger(__name__)
+
+
+def _removesuffix(string: str, suffix: str) -> str:
+    if suffix and string.endswith(suffix):
+        return string[: -len(suffix)]
+    return string
+
+
+class UnittestRunner(QualityAssuranceRunner):
+    """Quality assurance runner for unittest testing. Scores based on the ratio of passed tests to total tests."""
+
+    NUM_TESTS_PATTERN: re.Pattern = re.compile(r"Ran (\d+) tests? in \d+\.\d+s")
+    NUM_FAILED_PATTERN: re.Pattern = re.compile(
+        r"FAILED \((?:failures=(\d+))?(?:, )?(?:errors=(\d+))?(?:, )?(?:skipped=(\d+))?\)|"
+        r"FAILED \((?:errors=(\d+))?(?:, )?(?:failures=(\d+))?(?:, )?(?:skipped=(\d+))?\)|"
+        r"FAILED \((?:skipped=(\d+))?(?:, )?(?:failures=(\d+))?(?:, )?(?:errors=(\d+))?\)"
+    )
+
+    def _install_dependencies(self, base: LayeredCommand) -> None:
+        return None
+
+    def _pre_command(self) -> None:
+        pass
+
+    def _post_command(self) -> None:
+        pass
+        # set_current_working_directory(self._cwd)
+
+    def __init__(
+        self,
+        target: Optional[str] = "./tests",
+        bound: str = ">=0.8",
+        no_tests_score: float = 0,
+    ) -> None:
+        QualityAssuranceRunner.__init__(
+            self, name="unittest", bound=bound, target=target
+        )
+        self.no_tests_score = no_tests_score
+        logger.info(
+            "Initialized UnittestRunner with target='%s', bound='%s', no_tests_score=%s",
+            target,
+            bound,
+            no_tests_score,
+        )
+
+    def _build_command(
+        self, src: str, *args: Any, use_system_interpreter: bool = False
+    ) -> str:
+        command: str = self.get_executable()
+        target = self.target or "./tests"
+        rel = _removesuffix(os.path.relpath(src, target), src.lstrip("./\\"))
+        command += f" discover -s {rel}"
+        normalized_target_path = Path(os.path.join(os.getcwd(), target)).resolve()
+        # This is for concurrency reasons
+        return f"cd {normalized_target_path} & {command} & cd {Path(os.getcwd()).resolve()}"
+
+    def _calculate_score(
+        self, ret: int, lines: List[str], *, verbose: bool = False
+    ) -> float:
+        logger.info("Calculating unittest score from test results")
+
+        try:
+            num_tests_ran_line = lines[-3]
+            num_tests_failed_line = lines[-1]
+            match = self.NUM_TESTS_PATTERN.match(num_tests_ran_line)
+            if match is None:
+                raise ValueError(
+                    f"Failed to parse test count from line: {num_tests_ran_line}"
+                )
+            num_tests = int(match.group(1))
+            if num_tests == 0:
+                logger.info(
+                    "No tests found, returning no_tests_score: %s", self.no_tests_score
+                )
+                return self.no_tests_score
+
+            num_failed = 0
+            num_errors = 0
+            if num_tests_failed_line != "OK":
+                if num_tests_failed_line.startswith("FAILED"):
+                    m = self.NUM_FAILED_PATTERN.match(num_tests_failed_line)
+                    if m:
+                        # Handle different group positions based on the pattern that matched
+                        groups = m.groups()
+                        if groups[0] is not None:  # failures= first pattern
+                            num_failed = int(groups[0] or "0")
+                            num_errors = int(groups[1] or "0")
+                        elif groups[3] is not None:  # errors= first pattern
+                            num_failed = int(groups[4] or "0")
+                            num_errors = int(groups[3] or "0")
+                        elif groups[6] is not None:  # skipped= first pattern
+                            num_failed = int(groups[7] or "0")
+                            num_errors = int(groups[8] or "0")
+                        else:
+                            # Fallback to original logic if no groups match
+                            num_failed = int(m.group(1) or "0")
+                            num_errors = int(m.group(2) or "0")
+                    else:
+                        # If regex doesn't match, treat as malformed
+                        raise ValueError(
+                            f"Failed to parse FAILED line: {num_tests_failed_line}"
+                        )
+                elif num_tests_failed_line.startswith("OK"):
+                    # 'OK (skipped=3)' could it also be other stuff?
+                    pass
+
+            score = 1 - ((num_failed + num_errors) / num_tests)
+            logger.info(
+                "Unittest score calculated: %.3f (tests: %d, failed: %d, errors: %d)",
+                score,
+                num_tests,
+                num_failed,
+                num_errors,
+            )
+            return score
+
+        except Exception as e:
+            logger.error("Failed to calculate unittest score: %s", e)
+            raise ExitEarlyError(
+                f"Failed running Unittest, got exit code {ret}. "
+                f"try running manually using: {self._build_command('TARGET')}"
+            ) from e
+
+
+__all__ = [
+    "UnittestRunner",
+]

quickpub/strategies/implementations/upload_targets/__init__.py

@@ -0,0 +1,2 @@
+from .github_upload_target import *
+from .pypirc_upload_target import *

quickpub/strategies/implementations/upload_targets/github_upload_target.py

@@ -0,0 +1,61 @@
+import logging
+from typing import Any
+
+from ...upload_target import UploadTarget
+
+logger = logging.getLogger(__name__)
+
+
+class GithubUploadTarget(UploadTarget):
+    """Upload target implementation for GitHub releases. Commits and pushes changes to the git repository."""
+
+    def upload(self, name: str, version: str, **kwargs: Any) -> None:  # type: ignore[override]
+        from quickpub.proxy import cm
+        from quickpub.enforcers import exit_if
+
+        logger.info("Starting GitHub upload for version '%s'", version)
+
+        if self.verbose:
+            logger.debug("Staging files for Git commit")
+
+        ret, stdout, stderr = cm("git add .")
+        if ret != 0:
+            logger.error(
+                "Git add failed with return code %d: %s",
+                ret,
+                stderr.decode(encoding="utf8"),
+            )
+            exit_if(ret != 0, stderr.decode(encoding="utf8"))
+
+        if self.verbose:
+            logger.debug(
+                "Committing changes with message 'updated to version %s'", version
+            )
+
+        ret, stdout, stderr = cm(f'git commit -m "updated to version {version}"')
+        if ret != 0:
+            logger.error(
+                "Git commit failed with return code %d: %s",
+                ret,
+                stderr.decode(encoding="utf8"),
+            )
+            exit_if(ret != 0, stderr.decode(encoding="utf8"))
+
+        if self.verbose:
+            logger.debug("Pushing changes to GitHub")
+
+        ret, stdout, stderr = cm("git push")
+        if ret != 0:
+            logger.error(
+                "Git push failed with return code %d: %s",
+                ret,
+                stderr.decode(encoding="utf8"),
+            )
+            exit_if(ret != 0, stderr.decode(encoding="utf8"))
+
+        logger.info("Successfully uploaded version '%s' to GitHub", version)
+
+
+__all__ = [
+    "GithubUploadTarget",
+]

quickpub/strategies/implementations/upload_targets/pypirc_upload_target.py

@@ -0,0 +1,90 @@
+import logging
+import re
+from pathlib import Path
+from typing import Any
+
+from danielutils import file_exists
+
+from ....dist_files import find_sdist
+from ..constraint_enforcers import PypircEnforcer
+from ...upload_target import UploadTarget
+
+logger = logging.getLogger(__name__)
+
+
+class PypircUploadTarget(UploadTarget):
+    """Upload target implementation using .pypirc configuration. Uploads packages to PyPI using twine."""
+
+    REGEX_PATTERN: re.Pattern = PypircEnforcer.PYPIRC_REGEX
+
+    def upload(self, name: str, version: str, **kwargs: Any) -> None:  # type: ignore[override]
+        from quickpub.proxy import cm
+        from quickpub.enforcers import exit_if
+
+        logger.info("Starting PyPI upload for package '%s' version '%s'", name, version)
+
+        self._validate_file_exists()
+        self._validate_file_contents()
+
+        if self.verbose:
+            logger.info("Uploading package to PyPI")
+
+        sdist_path = find_sdist(Path("dist"), name, version)
+        ret, stdout, stderr = cm(
+            "twine",
+            "upload",
+            "--config-file",
+            ".pypirc",
+            sdist_path.as_posix(),
+        )
+
+        if ret != 0:
+            logger.error("PyPI upload failed with return code %d: %s", ret, stderr)
+            exit_if(
+                ret != 0,
+                f"Failed uploading the package to pypi. Try running the following command manually:\n"
+                f"\ttwine upload --config-file .pypirc {sdist_path.as_posix()}",
+            )
+
+        logger.info(
+            "Successfully uploaded package '%s' version '%s' to PyPI", name, version
+        )
+
+    def _validate_file_exists(self) -> None:
+        logger.debug("Validating .pypirc file exists at '%s'", self.pypirc_file_path)
+        if not file_exists(self.pypirc_file_path):
+            logger.error(".pypirc file not found at '%s'", self.pypirc_file_path)
+            raise RuntimeError(
+                f"{self.__class__.__name__} can't find pypirc file at '{self.pypirc_file_path}'"
+            )
+        logger.debug(".pypirc file found at '%s'", self.pypirc_file_path)
+
+    def _validate_file_contents(self) -> None:
+        logger.debug("Validating .pypirc file contents at '%s'", self.pypirc_file_path)
+        with open(self.pypirc_file_path, "r", encoding="utf8") as f:
+            text = f.read()
+        if not self.REGEX_PATTERN.match(text):
+            logger.error(
+                ".pypirc file contents validation failed for '%s'",
+                self.pypirc_file_path,
+            )
+            raise RuntimeError(
+                f"{self.__class__.__name__} checked the contents of '{self.pypirc_file_path}' and it failed to match the following regex: r\"{self.REGEX_PATTERN.pattern}\""
+            )
+        logger.debug(
+            ".pypirc file contents validation passed for '%s'", self.pypirc_file_path
+        )
+
+    def __init__(
+        self, pypirc_file_path: str = "./.pypirc", verbose: bool = False
+    ) -> None:
+        super().__init__(verbose)
+        self.pypirc_file_path = pypirc_file_path
+        logger.info(
+            "Initialized PypircUploadTarget with pypirc_file_path='%s', verbose=%s",
+            pypirc_file_path,
+            verbose,
+        )
+
+
+__all__ = ["PypircUploadTarget"]

quickpub/strategies/package_manager.py

@@ -0,0 +1,54 @@
+import logging
+from abc import abstractmethod
+from typing import Dict, Union
+
+from danielutils.async_.async_layered_command import AsyncLayeredCommand
+
+from .quickpub_strategy import QuickpubStrategy
+from ..enforcers import exit_if
+from ..structures import Dependency
+from .implementations.package_managers.installed_package_parser import (
+    parse_installed_packages_output,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class PackageManager(QuickpubStrategy):
+    async def prepare(self, executor: AsyncLayeredCommand) -> None:
+        return None
+
+    @abstractmethod
+    async def list_installed(
+        self, executor: AsyncLayeredCommand, env_name: str
+    ) -> Dict[str, Union[str, Dependency]]: ...
+
+    @abstractmethod
+    def install_command(self, package: str) -> str: ...
+
+    @abstractmethod
+    def show_command(self, package: str) -> str: ...
+
+    @abstractmethod
+    def wrap_command(self, command: str) -> str: ...
+
+    async def _list_installed_from_command(
+        self,
+        executor: AsyncLayeredCommand,
+        env_name: str,
+        list_command: str,
+    ) -> Dict[str, Union[str, Dependency]]:
+        logger.debug(
+            "Executing '%s' on environment '%s'", list_command, env_name
+        )
+        code, out, _ = await executor(list_command)
+        exit_if(
+            code != 0,
+            f"Failed executing '{list_command}' at env '{env_name}'",
+        )
+        currently_installed = parse_installed_packages_output(out)
+        logger.debug("Found %d installed packages", len(currently_installed))
+        return currently_installed
+
+
+__all__ = ["PackageManager"]