quickpub 4.1.4__py3-none-any.whl

quickpub/strategies/implementations/constraint_enforcers/pypi_remote_version_enforcer.py

@@ -0,0 +1,88 @@
+import logging
+import re
+from typing import Any
+
+from danielutils import RetryExecutor, MultiplicativeBackoff, ConstantBackOffStrategy
+from requests import Response
+
+from quickpub import Version
+from quickpub.proxy import get  # type: ignore
+from ...constraint_enforcer import ConstraintEnforcer
+
+logger = logging.getLogger(__name__)
+
+
+class PypiRemoteVersionEnforcer(ConstraintEnforcer):
+    """Enforces that the new version is greater than the latest version published on PyPI."""
+
+    _HTTP_FAILED_MESSAGE: str = "Failed to send http request"
+
+    def enforce(
+        self, name: str, version: Version, demo: bool = False, **kwargs: Any
+    ) -> None:  # type: ignore[override]
+        if demo:
+            return
+
+        logger.info(
+            "Checking remote version for package '%s' against version '%s'",
+            name,
+            version,
+        )
+        url = f"https://pypi.org/simple/{name}/"
+
+        timeout_strategy = MultiplicativeBackoff(2)
+
+        def wrapper() -> Response:
+            return get(url, timeout=timeout_strategy.get_backoff())
+
+        executor: RetryExecutor[Response] = RetryExecutor(ConstantBackOffStrategy(1))
+        response = executor.execute(wrapper, 5)
+        if response is None:
+            logger.error("Failed to fetch package information from PyPI for '%s'", name)
+            raise self.EXCEPTION_TYPE(self._HTTP_FAILED_MESSAGE)
+        html = response.content.decode()
+
+        # Parse version information from href attributes in anchor tags
+        # Pattern to match: <a href="...">package-name-version.tar.gz</a>
+        # <a href=.*?>(({re.escape(name)})-([^<]+)\.tar\.gz)<\/a><br \/>
+        version_pattern = re.compile(
+            rf"<a href=.*?>(({re.escape(name)})-([^<]+)\.tar\.gz)<\/a><br \/>"
+        )
+        matches = version_pattern.findall(html)
+
+        if not matches:
+            logger.error("No versions found for package '%s' on PyPI", name)
+            raise self.EXCEPTION_TYPE(f"No versions found for package '{name}' on PyPI")
+
+        # Extract all versions and find the latest
+        versions = []
+        for _, _, version_str in matches:
+            try:
+                # version_str already contains just the version (e.g., "0.0.0")
+                versions.append(Version.from_str(version_str))
+            except Exception:
+                # Skip invalid version strings
+                continue
+
+        if not versions:
+            logger.error("No valid versions found for package '%s' on PyPI", name)
+            raise self.EXCEPTION_TYPE(
+                f"No valid versions found for package '{name}' on PyPI"
+            )
+
+        remote_version = max(versions)
+
+        if not version > remote_version:
+            logger.error(
+                "Version conflict: specified '%s' is not greater than remote '%s'",
+                version,
+                remote_version,
+            )
+            raise self.EXCEPTION_TYPE(
+                f"Specified version is '{version}' but (remotely available) latest existing is '{remote_version}'"
+            )
+
+        logger.info("Version check passed: '%s' > '%s'", version, remote_version)
+
+
+__all__ = ["PypiRemoteVersionEnforcer"]

quickpub/strategies/implementations/constraint_enforcers/pypirc_enforcer.py

@@ -0,0 +1,45 @@
+import logging
+import re
+from typing import Any
+
+from danielutils import file_exists
+
+from ...constraint_enforcer import ConstraintEnforcer
+
+logger = logging.getLogger(__name__)
+
+
+class PypircEnforcer(ConstraintEnforcer):
+    """Enforces the presence and validity of a .pypirc configuration file for PyPI uploads."""
+
+    PYPIRC_REGEX: re.Pattern = re.compile(
+        r"\[distutils\]\nindex-servers =\n\s*pypi\n\s*testpypi\n\n\[pypi\]\n\s*username = __token__\n\s*password = .+\n\n\[testpypi\]\n\s*username = __token__\n\s*password = .+\n?"
+    )  # pylint: disable=line-too-long
+
+    def __init__(
+        self, path: str = "./.pypirc", should_enforce_expected_format: bool = True
+    ) -> None:
+        self.path = path
+        self.should_enforce_expected_format = should_enforce_expected_format
+
+    def enforce(self, **kwargs: Any) -> None:
+        logger.info("Validating .pypirc file at '%s'", self.path)
+
+        if not file_exists(self.path):
+            logger.error("Could not find .pypirc file at '%s'", self.path)
+            raise self.EXCEPTION_TYPE(f"Couldn't find '{self.path}'")
+
+        if self.should_enforce_expected_format:
+            with open(self.path, "r") as f:
+                text = f.read()
+
+            if not self.PYPIRC_REGEX.match(text):
+                logger.error("Invalid .pypirc format at '%s'", self.path)
+                raise self.EXCEPTION_TYPE(f"'{self.path}' has an invalid format.")
+
+        logger.info(".pypirc file validation passed for '%s'", self.path)
+
+
+__all__ = [
+    "PypircEnforcer",
+]

quickpub/strategies/implementations/constraint_enforcers/readme_enforcer.py

@@ -0,0 +1,29 @@
+import logging
+from typing import Any
+
+from danielutils import file_exists
+
+from ...constraint_enforcer import ConstraintEnforcer
+
+logger = logging.getLogger(__name__)
+
+
+class ReadmeEnforcer(ConstraintEnforcer):
+    """Enforces the presence of a README file at the specified path."""
+
+    def __init__(self, path: str = "./README.md") -> None:
+        self.path = path
+
+    def enforce(self, **kwargs: Any) -> None:
+        logger.info("Checking for readme file at '%s'", self.path)
+
+        if not file_exists(self.path):
+            logger.error("Readme file not found at '%s'", self.path)
+            raise self.EXCEPTION_TYPE(f"Could not find readme file at '{self.path}'")
+
+        logger.info("Readme file found at '%s'", self.path)
+
+
+__all__ = [
+    "ReadmeEnforcer",
+]

quickpub/strategies/implementations/package_managers/__init__.py

@@ -0,0 +1,2 @@
+from .pip_package_manager import *
+from .uv_package_manager import *

quickpub/strategies/implementations/package_managers/installed_package_parser.py

@@ -0,0 +1,29 @@
+import re
+from typing import Dict, List, Union
+
+from ....structures import Dependency, Version
+
+VERSION_REGEX: re.Pattern = re.compile(r"^\d+\.\d+\.\d+$")
+
+
+def parse_installed_packages_output(
+    output_lines: List[str],
+) -> Dict[str, Union[str, Dependency]]:
+    split_lines = (line.split(" ") for line in output_lines[2:])
+    version_tuples = [(s[0], s[-1].strip()) for s in split_lines if s[0]]
+    filtered_tuples = [t for t in version_tuples if VERSION_REGEX.match(t[1])]
+    currently_installed: Dict[str, Union[str, Dependency]] = {
+        name: Dependency(name, "==", Version.from_str(version))
+        for name, version in filtered_tuples
+    }
+    currently_installed.update(
+        **{
+            name: version
+            for name, version in version_tuples
+            if not VERSION_REGEX.match(version)
+        }
+    )
+    return currently_installed
+
+
+__all__ = ["parse_installed_packages_output", "VERSION_REGEX"]

quickpub/strategies/implementations/package_managers/pip_package_manager.py

@@ -0,0 +1,31 @@
+import logging
+from typing import Dict, Union
+
+from danielutils.async_.async_layered_command import AsyncLayeredCommand
+
+from ...package_manager import PackageManager
+from ....structures import Dependency
+
+logger = logging.getLogger(__name__)
+
+
+class PipPackageManager(PackageManager):
+    async def prepare(self, executor: AsyncLayeredCommand) -> None:
+        return None
+
+    async def list_installed(
+        self, executor: AsyncLayeredCommand, env_name: str
+    ) -> Dict[str, Union[str, Dependency]]:
+        return await self._list_installed_from_command(executor, env_name, "pip list")
+
+    def install_command(self, package: str) -> str:
+        return f"pip install {package}"
+
+    def show_command(self, package: str) -> str:
+        return f"pip show {package}"
+
+    def wrap_command(self, command: str) -> str:
+        return command
+
+
+__all__ = ["PipPackageManager"]

quickpub/strategies/implementations/package_managers/uv_package_manager.py

@@ -0,0 +1,45 @@
+import logging
+from pathlib import Path
+from typing import Dict, Union
+
+from danielutils.async_.async_layered_command import AsyncLayeredCommand
+
+from ...package_manager import PackageManager
+from ....enforcers import exit_if
+from ....structures import Dependency
+
+logger = logging.getLogger(__name__)
+
+
+class UvPackageManager(PackageManager):
+    def __init__(self, project_root: Path) -> None:
+        self.project_root = project_root
+
+    async def prepare(self, executor: AsyncLayeredCommand) -> None:
+        lockfile = self.project_root / "uv.lock"
+        exit_if(
+            not lockfile.exists(),
+            f"uv.lock not found at '{lockfile}'. Run 'uv lock' before using UvPackageManager.",
+        )
+        logger.debug("Running 'uv sync' for project at '%s'", self.project_root)
+        code, _, _ = await executor("uv sync")
+        exit_if(code != 0, "Failed executing 'uv sync'")
+
+    async def list_installed(
+        self, executor: AsyncLayeredCommand, env_name: str
+    ) -> Dict[str, Union[str, Dependency]]:
+        return await self._list_installed_from_command(
+            executor, env_name, "uv pip list"
+        )
+
+    def install_command(self, package: str) -> str:
+        return f"uv add --dev {package}"
+
+    def show_command(self, package: str) -> str:
+        return f"uv pip show {package}"
+
+    def wrap_command(self, command: str) -> str:
+        return f"uv run -- {command}"
+
+
+__all__ = ["UvPackageManager"]

quickpub/strategies/implementations/python_providers/__init__.py

@@ -0,0 +1,4 @@
+from .conda_python_provider import *
+from .default_python_provider import *
+from .union_provider import *
+from .uv_python_provider import *

quickpub/strategies/implementations/python_providers/conda_python_provider.py

@@ -0,0 +1,54 @@
+import logging
+from typing import Tuple, Optional, Set, List
+from danielutils import AsyncLayeredCommand
+
+from ....enforcers import ExitEarlyError
+from ...python_provider import PythonProvider
+
+logger = logging.getLogger(__name__)
+
+
+class CondaPythonProvider(PythonProvider):
+    """Python provider implementation using conda environments. Iterates over specified conda environment names."""
+
+    def get_python_executable_name(self) -> str:
+        return "python"
+
+    def __init__(self, env_names: List[str]) -> None:
+        PythonProvider.__init__(
+            self, requested_envs=env_names, explicit_versions=[], exit_on_fail=True
+        )
+        self._cached_available_envs: Optional[Set[str]] = None
+        logger.info("Initialized CondaPythonProvider with environments: %s", env_names)
+
+    async def _get_available_envs_impl(self) -> Set[str]:
+        logger.info("Fetching available conda environments")
+        with AsyncLayeredCommand() as base:
+            code, out, err = await base("conda env list")
+        return set([line.split(" ")[0] for line in out[2:] if len(line.split(" ")) > 1])
+
+    async def __anext__(self) -> Tuple[str, AsyncLayeredCommand]:
+        if self.aiter_index >= len(self.requested_envs):
+            raise StopAsyncIteration
+
+        available_envs = await self._get_available_envs()
+        self.aiter_index += 1
+        name = self.requested_envs[self.aiter_index - 1]
+
+        logger.debug("Activating conda environment: %s", name)
+
+        if name not in available_envs:
+            logger.error(
+                "Environment '%s' not found in available conda environments", name
+            )
+            raise ExitEarlyError(
+                f"Can't find env '{name}' in list of conda environments, try 'conda env list'"
+            )
+
+        logger.debug("Successfully activated conda environment: %s", name)
+        return name, AsyncLayeredCommand(f"conda activate {name}")
+
+
+__all__ = [
+    "CondaPythonProvider",
+]

quickpub/strategies/implementations/python_providers/default_python_provider.py

@@ -0,0 +1,47 @@
+import logging
+import sys
+from typing import Set, Tuple, AsyncIterator, Iterable, Any
+
+from danielutils.async_.async_layered_command import AsyncLayeredCommand
+
+from ...python_provider import PythonProvider
+
+logger = logging.getLogger(__name__)
+
+
+async def cast_aiter(itr: Iterable[Any]) -> AsyncIterator[Any]:
+    for x in itr:
+        yield x
+
+
+class DefaultPythonProvider(PythonProvider):
+    """Default Python provider using the system Python interpreter. Provides a single 'system' environment."""
+
+    def get_python_executable_name(self) -> str:
+        return sys.executable
+
+    def __init__(self) -> None:
+        PythonProvider.__init__(
+            self, requested_envs=["system"], explicit_versions=[], exit_on_fail=True
+        )
+        logger.info(
+            "Initialized DefaultPythonProvider with system Python: %s", sys.executable
+        )
+
+    async def __anext__(self) -> Tuple[str, AsyncLayeredCommand]:
+        if self.aiter_index == 0:
+            self.aiter_index += 1
+            logger.info("Using system Python environment")
+            executor = AsyncLayeredCommand()
+            executor.prev = None
+            return "system", executor
+        raise StopAsyncIteration
+
+    @classmethod
+    async def _get_available_envs_impl(cls) -> Set[str]:
+        return {"system"}
+
+
+__all__ = [
+    "DefaultPythonProvider",
+]

quickpub/strategies/implementations/python_providers/union_provider.py

@@ -0,0 +1,52 @@
+import logging
+from typing import List, Set, Tuple
+
+from danielutils.async_.async_layered_command import AsyncLayeredCommand
+
+from ...python_provider import PythonProvider
+
+logger = logging.getLogger(__name__)
+
+
+class UnionProvider(PythonProvider):
+    def __init__(self, providers: List[PythonProvider]) -> None:
+        requested_envs = [env for provider in providers for env in provider.requested_envs]
+        PythonProvider.__init__(
+            self,
+            requested_envs=requested_envs,
+            explicit_versions=[],
+            exit_on_fail=any(provider.exit_on_fail for provider in providers),
+        )
+        self.providers = providers
+        self._child_index = 0
+        self._child_iterator = None
+        logger.info(
+            "Initialized UnionProvider with %d child providers", len(providers)
+        )
+
+    def get_python_executable_name(self) -> str:
+        if not self.providers:
+            raise RuntimeError("UnionProvider has no child providers")
+        return self.providers[0].get_python_executable_name()
+
+    async def __anext__(self) -> Tuple[str, AsyncLayeredCommand]:
+        while self._child_index < len(self.providers):
+            if self._child_iterator is None:
+                self._child_iterator = self.providers[self._child_index].__aiter__()
+
+            try:
+                return await self._child_iterator.__anext__()
+            except StopAsyncIteration:
+                self._child_index += 1
+                self._child_iterator = None
+
+        raise StopAsyncIteration
+
+    async def _get_available_envs_impl(self) -> Set[str]:
+        available_envs: Set[str] = set()
+        for provider in self.providers:
+            available_envs.update(await provider._get_available_envs())
+        return available_envs
+
+
+__all__ = ["UnionProvider"]

quickpub/strategies/implementations/python_providers/uv_python_provider.py

@@ -0,0 +1,39 @@
+from pathlib import Path
+from typing import Set, Tuple
+
+from danielutils.async_.async_layered_command import AsyncLayeredCommand
+
+from ...python_provider import PythonProvider
+from ..package_managers.uv_package_manager import UvPackageManager
+
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class UvPythonProvider(PythonProvider):
+    def __init__(self, project_root: Path) -> None:
+        PythonProvider.__init__(
+            self, requested_envs=["uv"], explicit_versions=[], exit_on_fail=True
+        )
+        self.project_root = project_root
+        self.package_manager = UvPackageManager(project_root=project_root)
+        logger.info("Initialized UvPythonProvider for project at '%s'", project_root)
+
+    def get_python_executable_name(self) -> str:
+        return str(self.project_root / ".venv" / "bin" / "python")
+
+    async def __anext__(self) -> Tuple[str, AsyncLayeredCommand]:
+        if self.aiter_index == 0:
+            self.aiter_index += 1
+            logger.info("Using uv-managed Python environment")
+            executor = AsyncLayeredCommand()
+            executor.prev = None
+            return "uv", executor
+        raise StopAsyncIteration
+
+    async def _get_available_envs_impl(self) -> Set[str]:
+        return {"uv"}
+
+
+__all__ = ["UvPythonProvider"]

quickpub/strategies/implementations/quality_assurance_runners/__init__.py

@@ -0,0 +1,4 @@
+from .mypy_qa_runner import *
+from .pylint_qa_runner import *
+from .pytest_qa_runner import *
+from .unittest_qa_runner import *

quickpub/strategies/implementations/quality_assurance_runners/mypy_qa_runner.py

@@ -0,0 +1,98 @@
+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 MypyRunner(QualityAssuranceRunner):
+    """Quality assurance runner for mypy type checking. Scores based on the number of type errors found."""
+
+    NO_TESTS_PATTERN: re.Pattern = re.compile(
+        r"There are no \.py\[i\] files in directory '[\w\.\\\/]+'"
+    )
+    RATING_PATTERN: re.Pattern = re.compile(
+        r"Found (\d+(?:\.\d+)?) errors? in (\d+(?:\.\d+)?) files? \(checked (\d+(?:\.\d+)?) source files?\)"
+    )
+
+    def _install_dependencies(self, base: LayeredCommand) -> None:
+        logger.info("Installing mypy dependencies")
+        with base:
+            base(self.package_manager.install_command("mypy"))
+
+    def _build_command(self, target: str, use_system_interpreter: bool = False) -> str:
+        command: str = self.get_executable(use_system_interpreter)
+        if self.has_config:
+            command += f" --config-file {self.config_path}"
+        command += f" {target}"
+        return command
+
+    def __init__(
+        self,
+        bound: str = "<15",
+        configuration_path: Optional[str] = None,
+        executable_path: Optional[str] = None,
+        package_manager=None,
+    ) -> None:
+        QualityAssuranceRunner.__init__(
+            self,
+            name="mypy",
+            bound=bound,
+            configuration_path=configuration_path,
+            executable_path=executable_path,
+            package_manager=package_manager,
+        )
+        logger.info(
+            "Initialized MypyRunner with bound='%s', config='%s', executable='%s'",
+            bound,
+            configuration_path,
+            executable_path,
+        )
+
+    def _calculate_score(
+        self, ret: int, lines: List[str], verbose: bool = False
+    ) -> float:
+        from quickpub.enforcers import exit_if
+
+        logger.debug("Calculating mypy score from type checking results")
+
+        rating_line = lines[-1]
+        if self.NO_TESTS_PATTERN.match(rating_line):
+            logger.debug(
+                "No Python files found for type checking, returning score: 0.0"
+            )
+            return 0.0
+
+        if rating_line.endswith("No module named mypy"):
+            logger.error("Mypy module not found")
+            raise ExitEarlyError("Mypy is not installed.")
+
+        if rating_line.startswith("mypy: error: Cannot find config file"):
+            logger.error("Config file error: %s", rating_line)
+            raise ExitEarlyError(rating_line)
+
+        if rating_line.startswith("Success"):
+            logger.debug("Mypy type checking successful, returning score: 0.0")
+            return 0.0
+
+        m = self.RATING_PATTERN.match(rating_line)
+        exit_if(
+            m is None,
+            f"Failed running MyPy, got exit code {ret}. try running manually using: {self._build_command('TARGET')}",
+        )
+        assert m is not None  # For type checker
+        num_failed = float(m.group(1))
+        # active_files = float(m.group(2))  # type :ignore
+        # total_files = float(m.group(3))  # type :ignore
+        logger.debug("Mypy score calculated: %s type errors found", num_failed)
+        return num_failed
+
+
+__all__ = [
+    "MypyRunner",
+]