quickpub 4.1.4__py3-none-any.whl

quickpub/qa.py

@@ -0,0 +1,409 @@
+import logging
+import sys
+import time
+from abc import abstractmethod
+from typing import (
+    ContextManager,
+    List,
+    Callable,
+    Tuple,
+    Dict,
+    Union,
+    Any,
+    Literal,
+    Optional,
+    Protocol,
+    runtime_checkable,
+)
+from danielutils import TemporaryFile, AsyncWorkerPool, RandomDataGenerator
+from danielutils.async_.async_layered_command import AsyncLayeredCommand
+
+from .enforcers import ExitEarlyError
+from .strategies import (
+    PythonProvider,
+    QualityAssuranceRunner,
+    PackageManager,
+    PipPackageManager,
+)  # pylint: disable=relative-beyond-top-level
+from .structures import Dependency, Version  # pylint: disable=relative-beyond-top-level
+from .enforcers import exit_if  # pylint: disable=relative-beyond-top-level
+from .worker_pool import WorkerPool
+
+logger = logging.getLogger(__name__)
+
+try:
+    from danielutils import MultiContext  # type:ignore
+except ImportError:
+
+    class MultiContext(ContextManager[Any]):  # type: ignore[misc,no-redef]
+        def __init__(self, *contexts: ContextManager[Any]) -> None:
+            self.contexts = contexts
+
+        def __enter__(self) -> Any:  # type: ignore[return-value]
+            for context in self.contexts:
+                context.__enter__()
+            return self
+
+        def __exit__(
+            self,
+            exc_type: Optional[type[BaseException]],
+            exc_val: Optional[BaseException],
+            exc_tb: Optional[Any],
+        ) -> Optional[bool]:
+            for context in self.contexts:
+                context.__exit__(exc_type, exc_val, exc_tb)
+            return None
+
+        def __getitem__(self, index: int) -> ContextManager[Any]:
+            return self.contexts[index]
+
+
+ASYNC_POOL_NAME: str = "Quickpub QA"
+
+
+@runtime_checkable
+class SupportsProgress(Protocol):
+    """Protocol for progress bar objects. Compatible with tqdm and similar progress tracking libraries."""
+
+    @abstractmethod
+    def update(self, amount: int) -> None:
+        """Update the progress bar by the specified amount."""
+
+    @property
+    @abstractmethod
+    def total(self) -> int:
+        """Get the total number of items to process."""
+
+    @total.setter
+    @abstractmethod
+    def total(self, amount: int) -> None:
+        """Set the total number of items to process."""
+
+
+async def global_import_sanity_check(
+    package_name: str,
+    executor: AsyncLayeredCommand,
+    is_system_interpreter: bool,
+    env_name: str,
+    task_id: int,
+    pbar: Optional[SupportsProgress] = None,
+) -> None:
+    logger.info(
+        "Running global import sanity check for package '%s' on environment '%s'",
+        package_name,
+        env_name,
+    )
+    try:
+        p = sys.executable if is_system_interpreter else "python"
+        file_name = f"./{RandomDataGenerator().name(15)}__sanity_check_main.py"
+        with TemporaryFile(file_name) as f:
+            f.writelines([f"from {package_name} import *"])
+            cmd = f"{p} {file_name}"
+            logger.debug("Executing sanity check command: %s", cmd)
+            code, stdout, stderr = await executor(cmd)
+
+            if code != 0:
+                logger.error(
+                    "Sanity check failed for package '%s' on environment '%s' with return code %d",
+                    package_name,
+                    env_name,
+                    code,
+                )
+                is_task_run_success[task_id] = False
+            else:
+                logger.debug(
+                    "Sanity check passed for package '%s' on environment '%s'",
+                    package_name,
+                    env_name,
+                )
+                is_task_run_success[task_id] = True
+
+            msg = f"Env '{env_name}' failed sanity check."
+            if stderr:
+                if stderr[0] == "Traceback (most recent call last):":
+                    msg += f" Got error '{stderr[-1]}' when tried 'from {package_name} import *'"
+            else:
+                msg += f" Try manually running the following script 'from {package_name} import *'"
+            exit_if(code != 0, msg)
+    except Exception as e:
+        logger.error(
+            "Sanity check encountered unexpected error for package '%s' on environment '%s': %s",
+            package_name,
+            env_name,
+            e,
+        )
+        is_task_run_success[task_id] = False
+        raise
+    finally:
+        if pbar is not None:
+            pbar.update(1)
+
+
+async def _get_installed_packages(
+    executor: AsyncLayeredCommand, env_name: str
+) -> Dict[str, Union[str, Dependency]]:
+    return await PipPackageManager().list_installed(executor, env_name)
+
+
+async def validate_dependencies(
+    validation_exit_on_fail: bool,
+    required_dependencies: List[Dependency],
+    executor: AsyncLayeredCommand,
+    env_name: str,
+    task_id: int,
+    pbar: Optional[SupportsProgress] = None,
+    package_manager: Optional[PackageManager] = None,
+) -> None:
+    if package_manager is None:
+        package_manager = PipPackageManager()
+    logger.info("Validating dependencies on environment '%s'", env_name)
+    try:
+        if validation_exit_on_fail:
+            currently_installed = await package_manager.list_installed(
+                executor, env_name
+            )
+            not_installed_properly = _check_dependency_satisfaction(
+                required_dependencies, currently_installed
+            )
+
+            if not_installed_properly:
+                logger.error(
+                    "Dependency validation failed on environment '%s': %s",
+                    env_name,
+                    not_installed_properly,
+                )
+                is_task_run_success[task_id] = False
+            else:
+                logger.debug(
+                    "Dependency validation passed on environment '%s'", env_name
+                )
+                is_task_run_success[task_id] = True
+
+            exit_if(
+                bool(not_installed_properly),
+                f"On env '{env_name}' the following dependencies have problems: {(not_installed_properly)}",
+            )
+    except Exception as e:
+        logger.error(
+            "Dependency validation encountered unexpected error on environment '%s': %s",
+            env_name,
+            e,
+        )
+        is_task_run_success[task_id] = False
+        raise
+    finally:
+        if pbar is not None:
+            pbar.update(1)
+
+
+def _check_dependency_satisfaction(
+    required_dependencies: List[Dependency],
+    currently_installed: Dict[str, Union[str, Dependency]],
+) -> List[Tuple[Dependency, str]]:
+    not_installed_properly: List[Tuple[Dependency, str]] = []
+    for req in required_dependencies:
+        if req.name not in currently_installed:
+            not_installed_properly.append((req, "dependency not found"))
+        else:
+            v = currently_installed[req.name]
+            if isinstance(v, str):
+                not_installed_properly.append(
+                    (
+                        req,
+                        "Version format of dependency is not currently supported by quickpub",
+                    )
+                )
+            elif isinstance(v, Dependency):
+                if not req.is_satisfied_by(v.ver):
+                    not_installed_properly.append((req, "Invalid version installed"))
+    return not_installed_properly
+
+
+# Track all QA tasks (dependencies, sanity checks, QA runners)
+is_task_run_success: List[bool] = []
+
+
+async def run_config(
+    env_name: str,
+    async_executor: AsyncLayeredCommand,
+    runner: QualityAssuranceRunner,
+    config_id: int,
+    task_id: int,
+    *,
+    is_system_interpreter: bool,
+    validation_exit_on_fail: bool,
+    src_folder_path: str,
+    pbar: Optional[SupportsProgress] = None,
+) -> None:
+    logger.info(
+        "Running QA config %d on environment '%s' with runner '%s'",
+        config_id,
+        env_name,
+        runner.__class__.__name__,
+    )
+    try:
+        await runner.run(
+            src_folder_path,
+            async_executor,
+            use_system_interpreter=is_system_interpreter,
+            env_name=env_name,
+        )
+        logger.debug(
+            "QA config %d completed successfully on environment '%s'",
+            config_id,
+            env_name,
+        )
+        is_task_run_success[task_id] = True
+    except ExitEarlyError as e:
+        logger.error(
+            "QA config %d failed on environment '%s': %s", config_id, env_name, e
+        )
+        is_task_run_success[task_id] = False
+        raise e
+    except Exception as e:
+        logger.error(
+            "QA config %d encountered unexpected error on environment '%s': %s",
+            config_id,
+            env_name,
+            e,
+        )
+        is_task_run_success[task_id] = False
+        if validation_exit_on_fail:
+            raise RuntimeError(
+                f"QA config {config_id} failed on environment '{env_name}': {e}"
+            ) from e
+        return
+    finally:
+        if pbar is not None:
+            pbar.update(1)
+
+
+def _setup_qa_environment(
+    python_provider: PythonProvider,
+) -> bool:
+    from .strategies import DefaultPythonProvider
+
+    return isinstance(python_provider, DefaultPythonProvider)
+
+
+async def _submit_qa_tasks(
+    python_provider: PythonProvider,
+    quality_assurance_strategies: List[QualityAssuranceRunner],
+    package_name: str,
+    src_folder_path: str,
+    dependencies: List[Dependency],
+    is_system_interpreter: bool,
+    pool: WorkerPool,
+    pbar: Optional[SupportsProgress],
+    package_manager: Optional[PackageManager] = None,
+) -> int:
+    if package_manager is None:
+        package_manager = PipPackageManager()
+    total = 0
+    task_id = 0
+    with AsyncLayeredCommand() as base:
+        async for env_name, async_executor in python_provider:
+            logger.debug("Setting up QA tasks for environment '%s'", env_name)
+            with async_executor:
+                async_executor.prev = base
+                await package_manager.prepare(async_executor)
+                await pool.submit(
+                    validate_dependencies,
+                    args=[
+                        python_provider.exit_on_fail,
+                        dependencies,
+                        async_executor,
+                        env_name,
+                        task_id,
+                        pbar,
+                    ],
+                    kwargs={"package_manager": package_manager},
+                    name=f"Validate dependencies for env '{env_name}'",
+                )
+                total += 1
+                task_id += 1
+                await pool.submit(
+                    global_import_sanity_check,
+                    args=[
+                        package_name,
+                        async_executor,
+                        is_system_interpreter,
+                        env_name,
+                        task_id,
+                        pbar,
+                    ],
+                    name=f"Global Import Sanity Check for env '{env_name}'",
+                )
+                total += 1
+                task_id += 1
+                for runner in quality_assurance_strategies:
+                    await pool.submit(
+                        run_config,
+                        args=[env_name, async_executor, runner, task_id, task_id],
+                        kwargs=dict(
+                            src_folder_path=src_folder_path,
+                            is_system_interpreter=is_system_interpreter,
+                            validation_exit_on_fail=python_provider.exit_on_fail,
+                            pbar=pbar,
+                        ),
+                        name=f"Run config for '{env_name}' + '{runner.__class__.__qualname__}'",
+                    )
+                    total += 1
+                    task_id += 1
+    if pbar is not None:
+        pbar.total = total
+    for _ in range(task_id):
+        is_task_run_success.append(False)
+    return total
+
+
+async def _execute_qa_tasks(
+    pool: WorkerPool,
+    total: int,
+    qa_start_time: float,
+) -> bool:
+    logger.info("Starting QA worker pool with %d total tasks", total)
+    await pool.start()
+    await pool.join()
+    success = all(is_task_run_success)
+    elapsed = time.perf_counter() - qa_start_time
+    logger.info("QA process completed in %.3fs. Success: %s", elapsed, success)
+    logger.debug("Task success breakdown: %s", is_task_run_success)
+    return success
+
+
+async def qa(
+    python_provider: PythonProvider,
+    quality_assurance_strategies: List[QualityAssuranceRunner],
+    package_name: str,
+    src_folder_path: str,
+    dependencies: List[Dependency],
+    pbar: Optional[SupportsProgress] = None,
+    package_manager: Optional[PackageManager] = None,
+) -> bool:
+    if package_manager is None:
+        package_manager = PipPackageManager()
+    logger.info(
+        "Starting QA process for package '%s' with %d QA strategies",
+        package_name,
+        len(quality_assurance_strategies),
+    )
+    qa_start_time = time.perf_counter()
+    is_task_run_success.clear()
+    is_system_interpreter = _setup_qa_environment(python_provider)
+    pool = WorkerPool(ASYNC_POOL_NAME, num_workers=5)
+    total = await _submit_qa_tasks(
+        python_provider,
+        quality_assurance_strategies,
+        package_name,
+        src_folder_path,
+        dependencies,
+        is_system_interpreter,
+        pool,
+        pbar,
+        package_manager,
+    )
+    return await _execute_qa_tasks(pool, total, qa_start_time)
+
+
+__all__ = ["qa", "SupportsProgress"]

quickpub/strategies/__init__.py

@@ -0,0 +1,8 @@
+from .implementations import *
+from .upload_target import *
+from .quality_assurance_runner import *
+from .quickpub_strategy import *
+from .build_schema import *
+from .python_provider import *
+from .package_manager import *
+from .constraint_enforcer import *

quickpub/strategies/build_schema.py

@@ -0,0 +1,21 @@
+import logging
+from abc import abstractmethod
+from typing import Any
+
+from .quickpub_strategy import QuickpubStrategy
+
+logger = logging.getLogger(__name__)
+
+
+class BuildSchema(QuickpubStrategy):
+    """Base class for build schema implementations. Subclass this to define custom build strategies."""
+
+    def __init__(self, verbose: bool = True) -> None:
+        self.verbose = verbose
+        logger.debug("BuildSchema initialized with verbose=%s", verbose)
+
+    @abstractmethod
+    def build(self, *args: Any, **kwargs: Any) -> None: ...
+
+
+__all__ = ["BuildSchema"]

quickpub/strategies/constraint_enforcer.py

@@ -0,0 +1,17 @@
+from abc import abstractmethod
+from typing import Any, Type
+
+from ..enforcers import ExitEarlyError
+from .quickpub_strategy import QuickpubStrategy
+
+
+class ConstraintEnforcer(QuickpubStrategy):
+    """Base class for constraint enforcer implementations. Subclass this to define custom constraint validation logic."""
+
+    EXCEPTION_TYPE: Type[Exception] = ExitEarlyError
+
+    @abstractmethod
+    def enforce(self, **kwargs: Any) -> None: ...
+
+
+__all__ = ["ConstraintEnforcer"]

quickpub/strategies/implementations/__init__.py

@@ -0,0 +1,6 @@
+from .constraint_enforcers import *
+from .build_schemas import *
+from .quality_assurance_runners import *
+from .upload_targets import *
+from .python_providers import *
+from .package_managers import *

quickpub/strategies/implementations/build_schemas/__init__.py

@@ -0,0 +1,2 @@
+from .setuptools_build_schema import *
+from .uv_build_schema import *

quickpub/strategies/implementations/build_schemas/setuptools_build_schema.py

@@ -0,0 +1,48 @@
+import logging
+import os
+import sys
+from pathlib import Path
+
+from danielutils import file_exists, LayeredCommand, delete_file
+
+from ...build_schema import BuildSchema
+
+logger = logging.getLogger(__name__)
+
+
+class SetuptoolsBuildSchema(BuildSchema):
+    """Build schema implementation using setuptools. Creates source distributions via setup.py."""
+
+    def __init__(self, setup_file_path: str = "./setup.py") -> None:
+        self._setup_file_path = setup_file_path
+
+    def build(self, verbose: bool = False, *args, **kwargs) -> None:
+        if not file_exists(self._setup_file_path):
+            logger.error("Setup file not found: %s", self._setup_file_path)
+            raise self.EXCEPTION_TYPE(f"Could not find {self._setup_file_path} file")
+
+        if verbose:
+            logger.info("Creating new distribution...")
+
+        sources_file_path: str = str(
+            os.path.join(
+                str(Path(self._setup_file_path).parent.resolve()),
+                "quickpub.egg-info/SOURCES.txt",
+            )
+        )
+
+        delete_file(sources_file_path)
+
+        with LayeredCommand() as exc:
+            ret, stdout, stderr = exc(
+                sys.executable + " " + self._setup_file_path + " sdist"
+            )
+
+        if ret != 0:
+            logger.error("Build command failed with return code %d: %s", ret, stderr)
+            raise self.EXCEPTION_TYPE(stderr)
+
+
+__all__ = [
+    "SetuptoolsBuildSchema",
+]

quickpub/strategies/implementations/build_schemas/uv_build_schema.py

@@ -0,0 +1,50 @@
+import logging
+from typing import Any
+
+from danielutils import file_exists, LayeredCommand
+
+from ...build_schema import BuildSchema
+
+logger = logging.getLogger(__name__)
+
+
+class UvBuildSchema(BuildSchema):
+    def __init__(
+        self,
+        pyproject_path: str = "./pyproject.toml",
+        sdist: bool = True,
+        wheel: bool = True,
+    ) -> None:
+        if not sdist and not wheel:
+            raise self.EXCEPTION_TYPE(
+                "UvBuildSchema requires at least one of sdist or wheel"
+            )
+        self._pyproject_path = pyproject_path
+        self._sdist = sdist
+        self._wheel = wheel
+
+    def build_command(self) -> str:
+        if self._sdist and self._wheel:
+            return "uv build"
+        if self._sdist:
+            return "uv build --sdist"
+        return "uv build --wheel"
+
+    def build(self, verbose: bool = False, *args: Any, **kwargs: Any) -> None:
+        if not file_exists(self._pyproject_path):
+            logger.error("pyproject.toml not found: %s", self._pyproject_path)
+            raise self.EXCEPTION_TYPE(f"Could not find {self._pyproject_path} file")
+
+        command = self.build_command()
+        if verbose:
+            logger.info("Creating new distribution with '%s'...", command)
+
+        with LayeredCommand() as executor:
+            ret, stdout, stderr = executor(command)
+
+        if ret != 0:
+            logger.error("Build command failed with return code %d: %s", ret, stderr)
+            raise self.EXCEPTION_TYPE(stderr)
+
+
+__all__ = ["UvBuildSchema"]

quickpub/strategies/implementations/constraint_enforcers/__init__.py

@@ -0,0 +1,5 @@
+from .local_version_enforcer import *
+from .license_enforcer import *
+from .pypi_remote_version_enforcer import *
+from .pypirc_enforcer import *
+from .readme_enforcer import *

quickpub/strategies/implementations/constraint_enforcers/license_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 LicenseEnforcer(ConstraintEnforcer):
+    """Enforces the presence of a license file at the specified path."""
+
+    def __init__(self, path: str = "./LICENSE") -> None:
+        self.path = path
+
+    def enforce(self, **kwargs: Any) -> None:
+        logger.info("Checking for license file at '%s'", self.path)
+
+        if not file_exists(self.path):
+            logger.error("License file not found at '%s'", self.path)
+            raise self.EXCEPTION_TYPE(f"Could not find license file at '{self.path}'")
+
+        logger.info("License file found at '%s'", self.path)
+
+
+__all__ = [
+    "LicenseEnforcer",
+]

quickpub/strategies/implementations/constraint_enforcers/local_version_enforcer.py

@@ -0,0 +1,80 @@
+import logging
+from typing import Any, Optional
+
+from danielutils import directory_exists, get_files
+
+from quickpub import Version
+from ...constraint_enforcer import ConstraintEnforcer
+
+logger = logging.getLogger(__name__)
+
+
+def _version_from_dist_filename(name: str, filename: str) -> Optional[Version]:
+    prefix = f"{name}-"
+    if not filename.startswith(prefix):
+        return None
+    if filename.endswith(".tar.gz"):
+        version_str = filename[len(prefix) : -len(".tar.gz")]
+    elif filename.endswith(".whl"):
+        version_str = filename[len(prefix) : -len(".whl")].split("-")[0]
+    else:
+        return None
+    try:
+        return Version.from_str(version_str)
+    except ValueError:
+        return None
+
+
+class LocalVersionEnforcer(ConstraintEnforcer):
+    """Enforces that the new version is greater than the highest version found in the local dist directory."""
+
+    def enforce(
+        self, name: str, version: Version, demo: bool = False, **kwargs: Any
+    ) -> None:  # type: ignore[override]
+        if demo:
+            return
+
+        logger.info(
+            "Checking local version for package '%s' against version '%s'",
+            name,
+            version,
+        )
+
+        if not directory_exists("./dist"):
+            logger.info("No dist directory found, skipping local version check")
+            return
+
+        prev_builds = get_files("./dist")
+        if len(prev_builds) == 0:
+            logger.info("No previous builds found in dist directory")
+            return
+
+        max_local_version = Version(0, 0, 0)
+        found_artifact = False
+        for filename in prev_builds:
+            parsed = _version_from_dist_filename(name, filename)
+            if parsed is None:
+                continue
+            found_artifact = True
+            max_local_version = max(max_local_version, parsed)
+
+        if not found_artifact:
+            logger.info("No sdist or wheel artifacts found in dist directory")
+            return
+
+        if version <= max_local_version:
+            logger.error(
+                "Version conflict: specified '%s' is not greater than local '%s'",
+                version,
+                max_local_version,
+            )
+            raise self.EXCEPTION_TYPE(
+                f"Specified version is '{version}' but (locally available) latest existing is '{max_local_version}'"
+            )
+
+        logger.info(
+            "Local version check passed: '%s' > '%s'", version, max_local_version
+        )
+
+
+__all__ = ["LocalVersionEnforcer"]