quickpub 4.1.4__py3-none-any.whl

quickpub/strategies/python_provider.py

@@ -0,0 +1,60 @@
+import logging
+from abc import abstractmethod
+from typing import Tuple, Set, List, AsyncIterator
+
+from .quickpub_strategy import QuickpubStrategy
+from danielutils.async_.async_layered_command import AsyncLayeredCommand
+
+logger = logging.getLogger(__name__)
+
+
+class PythonProvider(AsyncIterator, QuickpubStrategy):
+    """Base class for Python environment providers. Subclass this to define custom Python environment management strategies."""
+
+    def __init__(
+        self,
+        auto_install_dependencies: bool = True,
+        *,
+        requested_envs: List[str],
+        explicit_versions: List[str],
+        exit_on_fail: bool = False,
+    ) -> None:
+        self.auto_install_dependencies = auto_install_dependencies
+        self.requested_envs = requested_envs
+        self.explicit_versions = explicit_versions
+        self.exit_on_fail = exit_on_fail
+        self.aiter_index = 0
+
+    def __aiter__(self) -> AsyncIterator[Tuple[str, AsyncLayeredCommand]]:
+        self.aiter_index = 0
+        return self
+
+    @abstractmethod
+    async def __anext__(self) -> Tuple[str, AsyncLayeredCommand]: ...
+
+    async def _get_available_envs(self) -> Set[str]:
+        KEY = "__available_envs__"
+        if (res := getattr(self, KEY, None)) is not None:
+            logger.debug(
+                "Using cached available environments for %s", self.__class__.__name__
+            )
+            return res
+
+        logger.debug("Fetching available environments for %s", self.__class__.__name__)
+        setattr(self, KEY, res := await self._get_available_envs_impl())
+        logger.debug(
+            "Found %d available environments for %s", len(res), self.__class__.__name__
+        )
+        return res
+
+    @abstractmethod
+    async def _get_available_envs_impl(self) -> Set[str]: ...
+
+    def __len__(self) -> int:
+        return len(self.requested_envs)
+
+    @abstractmethod
+    def get_python_executable_name(self) -> str: ...
+
+
+__all__ = ["PythonProvider"]

quickpub/strategies/quality_assurance_runner.py

@@ -0,0 +1,208 @@
+import logging
+import subprocess
+import sys
+import time
+from abc import abstractmethod
+from typing import Union, List, Optional, cast, Dict, Tuple, TYPE_CHECKING
+from danielutils import LayeredCommand, file_exists
+from danielutils.async_.async_layered_command import AsyncLayeredCommand
+
+from quickpub import Bound
+
+if TYPE_CHECKING:
+    from .package_manager import PackageManager
+
+logger = logging.getLogger(__name__)
+
+
+class Configurable:
+    @property
+    def has_config(self) -> bool:
+        return self.config_path is not None
+
+    def __init__(self, config_path: Optional[str] = None):
+        self.config_path = config_path
+        if self.has_config:
+            logger.debug("Using configuration file: %s", self.config_path)
+            if not file_exists(self.config_path):
+                logger.error("Configuration file not found: %s", self.config_path)
+                raise FileNotFoundError(f"Can't find config file {self.config_path}")
+
+
+class HasOptionalExecutable:
+    PYTHON: str = sys.executable
+
+    @property
+    def use_executable(self) -> bool:
+        return self.executable_path is not None
+
+    def __init__(self, name: str, executable_path: Optional[str] = None) -> None:
+        self.name = name
+        self.executable_path = executable_path
+        if self.use_executable:
+            logger.debug("Using custom executable: %s", self.executable_path)
+            if not file_exists(self.executable_path):
+                logger.error("Executable not found: %s", self.executable_path)
+                raise FileNotFoundError(f"Executable not found {self.executable_path}")
+        else:
+            logger.debug("Using system executable for: %s", name)
+
+    def get_executable(self, use_system_interpreter: bool = False) -> str:
+        if self.use_executable:
+            return cast(str, self.executable_path)
+
+        p = self.PYTHON
+        if use_system_interpreter:
+            p = sys.executable
+        return f"{p} -m {self.name}"
+
+
+SPEICLA_EXIT_CODES: Dict[int, Tuple[str, str]] = {
+    -1073741515: (
+        "Can't find python in path.",
+        "Executing command '{command}' failed with exit code {ret} which in hex is {hex} which corresponds to STATUS_DLL_NOT_FOUND",
+    ),
+    3221225781: (
+        "Can't find python in path.",
+        "Executing command '{command}' failed with exit code {ret} which in hex is {hex} which corresponds to STATUS_DLL_NOT_FOUND",
+    ),
+}
+
+
+class QualityAssuranceRunner(Configurable, HasOptionalExecutable):
+    def __init__(
+        self,
+        *,
+        name: str,
+        bound: Union[str, Bound],
+        target: Optional[str] = None,
+        configuration_path: Optional[str] = None,
+        executable_path: Optional[str] = None,
+        package_manager: Optional["PackageManager"] = None,
+    ) -> None:
+        from .package_manager import PackageManager as PackageManagerType
+        from .implementations.package_managers.pip_package_manager import (
+            PipPackageManager,
+        )
+
+        Configurable.__init__(self, configuration_path)
+        HasOptionalExecutable.__init__(self, name, executable_path)
+        self.package_manager: PackageManagerType = (
+            package_manager if package_manager is not None else PipPackageManager()
+        )
+        self.bound: Bound = (
+            bound if isinstance(bound, Bound) else Bound.from_string(bound)
+        )
+        self.target = target
+        logger.debug(
+            "QualityAssuranceRunner '%s' initialized with bound=%s, target=%s",
+            name,
+            self.bound,
+            target,
+        )
+
+    @abstractmethod
+    def _build_command(
+        self, target: str, use_system_interpreter: bool = False
+    ) -> str: ...
+
+    @abstractmethod
+    def _install_dependencies(self, base: LayeredCommand) -> None: ...
+
+    def _pre_command(self) -> None: ...
+
+    def _post_command(self) -> None: ...
+
+    def _handle_special_exit_codes(self, ret: int, command: str) -> None:
+        if ret in SPEICLA_EXIT_CODES:
+            title, explanation = SPEICLA_EXIT_CODES[ret]
+            unsigned_integer_ret = ret + 2**32
+            logger.error("Special exit code %d encountered: %s", ret, title)
+            raise RuntimeError(
+                title
+                + "\n\t"
+                + explanation.format(
+                    command=command, ret=ret, hex=hex(unsigned_integer_ret)
+                )
+            )
+
+    def _validate_score_against_bound(
+        self, score: float, env_name: str, verbose: bool = False
+    ) -> None:
+        from quickpub.enforcers import exit_if  # pylint: disable=import-error
+
+        logger.debug(
+            "QA runner '%s' scored %.3f (bound: %s)",
+            self.__class__.__name__,
+            score,
+            self.bound,
+        )
+
+        if not self.bound.compare_against(score):
+            logger.error(
+                "QA runner '%s' failed bound check: %s vs %s",
+                self.__class__.__name__,
+                score,
+                self.bound,
+            )
+
+        exit_if(
+            not self.bound.compare_against(score),
+            f"On env '{env_name}' runner '{self.__class__.__name__}' failed to pass its defined bound. Got a score of {score} but expected {self.bound}",
+        )
+
+    async def run(
+        self,
+        target: str,
+        executor: AsyncLayeredCommand,
+        *,
+        verbose: bool = True,  # type: ignore
+        use_system_interpreter: bool = False,
+        env_name: str,
+    ) -> None:
+        logger.debug(
+            "Running %s on environment '%s' with target '%s'",
+            self.__class__.__name__,
+            env_name,
+            target,
+        )
+
+        command = self._build_command(target, use_system_interpreter)
+        command = self.package_manager.wrap_command(command)
+        logger.debug("Built command: %s", command)
+
+        self._pre_command()
+        start_time = time.perf_counter()
+        try:
+            ret, out, err = await executor(command, command_raise_on_fail=False)
+            self._handle_special_exit_codes(ret, command)
+
+            score = self._calculate_score(ret, out + err, verbose=verbose)
+            self._validate_score_against_bound(score, env_name, verbose)
+        except Exception as e:
+            logger.error(
+                "QA runner '%s' failed on env '%s': %s",
+                self.__class__.__name__,
+                env_name,
+                e,
+            )
+            raise RuntimeError(
+                f"On env {env_name}, failed to run {self.__class__.__name__}. Try running manually:\n{executor._build_command(command)}",
+                e,
+            ) from e
+        finally:
+            elapsed = time.perf_counter() - start_time
+            logger.info(
+                "QA runner '%s' finished in %.3fs",
+                self.__class__.__name__,
+                elapsed,
+            )
+            self._post_command()
+
+    @abstractmethod
+    def _calculate_score(
+        self, ret: int, command_output: List[str], *, verbose: bool = False
+    ) -> float: ...
+
+
+__all__ = ["QualityAssuranceRunner"]

quickpub/strategies/quickpub_strategy.py

@@ -0,0 +1,14 @@
+from typing import Type
+
+from danielutils.university.oop.strategy import Strategy
+
+from ..enforcers import ExitEarlyError
+
+
+class QuickpubStrategy(Strategy):
+    EXCEPTION_TYPE: Type[Exception] = ExitEarlyError
+
+
+__all__ = [
+    "QuickpubStrategy",
+]

quickpub/strategies/upload_target.py

@@ -0,0 +1,19 @@
+from abc import abstractmethod
+from typing import Any
+
+from .quickpub_strategy import QuickpubStrategy
+
+
+class UploadTarget(QuickpubStrategy):
+    """Base class for upload target implementations. Subclass this to define custom upload strategies."""
+
+    def __init__(self, verbose: bool = True) -> None:
+        self.verbose = verbose
+
+    @abstractmethod
+    def upload(self, **kwargs: Any) -> None: ...
+
+
+__all__ = [
+    "UploadTarget",
+]

quickpub/structures/__init__.py

@@ -0,0 +1,3 @@
+from .bound import *
+from .version import *
+from .dependency import *

quickpub/structures/bound.py

@@ -0,0 +1,52 @@
+import logging
+from dataclasses import dataclass
+from typing import Literal, List
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class Bound:
+    operator: Literal["<", "<=", "==", ">", ">="]
+    value: float
+
+    def compare_against(self, score: float) -> bool:
+        result = {
+            ">": score > self.value,
+            ">=": score >= self.value,
+            "<": score < self.value,
+            "<=": score <= self.value,
+            "==": score == self.value,
+        }[self.operator]
+        logger.debug(
+            "Bound comparison: %s %s %s = %s", score, self.operator, self.value, result
+        )
+        return result
+
+    @staticmethod
+    def from_string(s: str) -> "Bound":
+        logger.debug("Parsing bound from string: '%s'", s)
+        valid_operators: List[Literal["<", "<=", "==", ">", ">="]] = [
+            ">=",
+            "<=",
+            "==",
+            ">",
+            "<",
+        ]
+        for op in valid_operators:
+            splits = s.split(op)
+            if len(splits) == 2:
+                bound = Bound(op, float(splits[-1]))
+                logger.debug("Parsed bound: %s", bound)
+                return bound
+        logger.error("Failed to parse bound from string: '%s'", s)
+        raise ValueError("Invalid 'Bound' format")
+
+    def __str__(self) -> str:
+        return f"{self.operator}{self.value}"
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}(operator='{self.operator}', value='{self.value}')"
+
+
+__all__ = ["Bound"]

quickpub/structures/dependency.py

@@ -0,0 +1,82 @@
+import logging
+from typing import Literal, Callable, Dict, Any, List
+
+from .version import Version
+
+logger = logging.getLogger(__name__)
+
+
+class Dependency:
+    """Represents a package dependency with version constraints. Use from_string() to parse dependency strings."""
+
+    def _build_func_map(self) -> Dict[str, Callable[[Version], bool]]:
+        return {
+            "==": lambda v: v == self.ver,
+            ">=": lambda v: v >= self.ver,
+            "<=": lambda v: v <= self.ver,
+            ">": lambda v: v > self.ver,
+            "<": lambda v: v < self.ver,
+        }
+
+    def __init__(
+        self,
+        name: str,
+        operator: Literal["<", "<=", "==", ">", ">="] = ">=",
+        ver: Version = Version(0, 0, 0),
+    ) -> None:
+        self.name: str = name
+        self.operator: Literal["<", "<=", "==", ">", ">="] = operator
+        self.ver: Version = ver or Version(0, 0, 0)
+        logger.debug("Dependency created: %s %s %s", self.name, self.operator, self.ver)
+
+    def __eq__(self, other: Any) -> bool:
+        if not isinstance(other, Dependency):
+            return False
+        return (
+            self.name == other.name
+            and self.operator == other.operator
+            and self.ver == other.ver
+        )
+
+    def __hash__(self) -> int:
+        return hash((self.name, self.operator, self.ver))
+
+    @staticmethod
+    def from_string(s: str) -> "Dependency":
+        logger.debug("Parsing dependency from string: '%s'", s)
+        valid_operators: List[Literal["<", "<=", "==", ">", ">="]] = [
+            ">=",
+            "<=",
+            ">",
+            "<",
+            "==",
+        ]
+        for op in valid_operators:
+            splits = s.split(op)
+            if len(splits) == 2:
+                dep = Dependency(
+                    splits[0],
+                    op,
+                    Version.from_str(splits[-1]),
+                )
+                logger.debug("Parsed dependency: %s", dep)
+                return dep
+        dep = Dependency(s, ">=", Version(0, 0, 0))
+        logger.debug("Parsed dependency (default): %s", dep)
+        return dep
+
+    def __str__(self) -> str:
+        if self.ver == Version(0, 0, 0):
+            return self.name
+        return f"{self.name}{self.operator}{self.ver}"
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}(name='{self.name}', operator='{self.operator}', version='{self.ver}')"
+
+    def is_satisfied_by(self, ver: Version) -> bool:
+        result = self._build_func_map()[self.operator](ver)
+        logger.debug("Dependency '%s' satisfied by version '%s': %s", self, ver, result)
+        return result
+
+
+__all__ = ["Dependency"]

quickpub/structures/version.py

@@ -0,0 +1,41 @@
+import logging
+from dataclasses import dataclass
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass(order=True)
+class Version:
+    @staticmethod
+    def from_str(version_str: str) -> "Version":
+        try:
+            version = Version(*list(map(int, version_str.split("."))))
+            return version
+        except Exception as e:
+            logger.error("Failed to parse version from string '%s': %s", version_str, e)
+            raise ValueError(
+                f"Failed converting '{version_str}' to instance of 'Version' in 'Version.from_str"
+            ) from e
+
+    major: int = 0
+    minor: int = 0
+    patch: int = 0
+
+    def __init__(self, major: int = 0, minor: int = 0, patch: int = 0) -> None:
+        if not all(map(lambda x: isinstance(x, int) and x >= 0, [major, minor, patch])):
+            logger.error(
+                "Invalid version components: major=%s, minor=%s, patch=%s",
+                major,
+                minor,
+                patch,
+            )
+            raise ValueError("Version supports positive integers only")
+        self.major = major
+        self.minor = minor
+        self.patch = patch
+
+    def __str__(self) -> str:
+        return f"{self.major}.{self.minor}.{self.patch}"
+
+
+__all__ = ["Version"]

quickpub/validators.py

@@ -0,0 +1,87 @@
+import logging
+from typing import Optional, Union, List
+
+from danielutils import get_python_version
+
+from .enforcers import ExitEarlyError
+from .structures import Version, Dependency
+
+logger = logging.getLogger(__name__)
+
+
+def validate_version(version: Optional[Union[str, Version]] = None) -> Version:
+    logger.debug("Validating version: %s", version)
+    if not bool(version):
+        logger.error("Version validation failed: no version provided")
+        raise ExitEarlyError(f"Must supply a version number. got '{version}'")
+
+    if isinstance(version, Version):
+        logger.debug("Version is already a Version object: %s", version)
+        return version
+    logger.debug("Converting string version to Version object: %s", version)
+    if not isinstance(version, str):
+        raise ExitEarlyError(
+            f"Version must be a string or Version object, got '{type(version)}'"
+        )
+    return Version.from_str(version)
+
+
+def validate_python_version(min_python: Optional[Version]) -> Version:
+    logger.debug("Validating Python version. min_python: %s", min_python)
+    if min_python is not None:
+        logger.debug("Using provided minimum Python version: %s", min_python)
+        return min_python
+
+    current_version = Version(*get_python_version())
+    logger.debug("Using current Python version: %s", current_version)
+    return current_version
+
+
+def validate_keywords(keywords: Optional[List[str]]) -> List[str]:
+    logger.debug("Validating keywords: %s", keywords)
+    if keywords is None:
+        logger.debug("No keywords provided, returning empty list")
+        return []
+    logger.debug("Using provided keywords: %s", keywords)
+    return keywords
+
+
+def validate_dependencies(
+    dependencies: Optional[List[Union[str, Dependency]]],
+) -> List[Dependency]:
+    logger.debug("Validating dependencies: %s", dependencies)
+    if dependencies is None:
+        logger.debug("No dependencies provided, returning empty list")
+        return []
+
+    res = []
+    for dep in dependencies:
+        if isinstance(dep, str):
+            logger.debug("Converting string dependency to Dependency object: %s", dep)
+            res.append(Dependency.from_string(dep))
+        else:
+            logger.debug("Using existing Dependency object: %s", dep)
+            res.append(dep)
+
+    logger.debug("Validated %d dependencies", len(res))
+    return res
+
+
+def validate_source(name: str, src: Optional[str] = None) -> str:
+    logger.debug("Validating source for package '%s'. src: %s", name, src)
+    if src is not None:
+        logger.debug("Using provided source path: %s", src)
+        return src
+
+    default_src = f"./{name}"
+    logger.debug("Using default source path: %s", default_src)
+    return default_src
+
+
+__all__ = [
+    "validate_version",
+    "validate_python_version",
+    "validate_keywords",
+    "validate_dependencies",
+    "validate_source",
+]

quickpub/worker_pool.py

@@ -0,0 +1,16 @@
+import logging
+from typing import Any
+from danielutils import AsyncWorkerPool
+
+logger = logging.getLogger(__name__)
+
+
+class WorkerPool(AsyncWorkerPool):
+    @staticmethod
+    def log(level: int, message: str, *args: Any, **kwargs: Any) -> None:
+        logger.log(level, message, *args, **kwargs)
+
+
+__all__ = [
+    "WorkerPool",
+]