quickpub 2.0.4__tar.gz → 3.0.0__tar.gz

{quickpub-2.0.4/quickpub.egg-info → quickpub-3.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: quickpub
-Version: 2.0.4
+Version: 3.0.0
 Summary: A python package to quickly configure and publish a new package
 Author-email: danielnachumdev <danielnachumdev@gmail.com>
 License: MIT License
@@ -33,8 +33,12 @@ Classifier: Operating System :: Microsoft :: Windows
 Requires-Python: >=3.8.0
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: danielutils>=1.0.0
+Requires-Dist: requests
+Requires-Dist: fire
+Dynamic: license-file
 
-# quickpub V2.0.2
+# quickpub V3.0.0
 **Tested python versions**: `3.8.0`, `3.9.0`, `3.10.13`,
 
 Example usage of how this package was published

{quickpub-2.0.4 → quickpub-3.0.0}/README.md

@@ -1,4 +1,4 @@
-# quickpub V2.0.2
+# quickpub V3.0.0
 **Tested python versions**: `3.8.0`, `3.9.0`, `3.10.13`,
 
 Example usage of how this package was published

{quickpub-2.0.4 → quickpub-3.0.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "quickpub"
-version = "2.0.4"
+version = "3.0.0"
 authors = [
     { name = "danielnachumdev", email = "danielnachumdev@gmail.com" },
 ]

{quickpub-2.0.4 → quickpub-3.0.0}/quickpub/__init__.py

@@ -1,3 +1,5 @@
 from .structures import *
 from .strategies import *
+from .enforcers import ExitEarlyError
+from .qa import SupportsProgress
 from .__main__ import publish

{quickpub-2.0.4 → quickpub-3.0.0}/quickpub/__main__.py

@@ -1,8 +1,10 @@
-from typing import Optional, Union, List, Any
+import asyncio
+from typing import Optional, Union, List, Any, Callable
 
 import fire
 from danielutils import warning, error
 
+from quickpub import ExitEarlyError
 from .strategies import BuildSchema, ConstraintEnforcer, UploadTarget, QualityAssuranceRunner, PythonProvider, \
     DefaultPythonProvider
 from .validators import validate_version, validate_python_version, validate_keywords, validate_dependencies, \
@@ -10,7 +12,7 @@ from .validators import validate_version, validate_python_version, validate_keyw
 from .structures import Version, Dependency
 from .files import create_toml, create_setup, create_manifest
 from .classifiers import *
-from .qa import qa
+from .qa import qa, SupportsProgress
 
 
 def publish(
@@ -34,12 +36,16 @@ def publish(
         dependencies: Optional[List[Union[str, Dependency]]] = None,
         keywords: Optional[List[str]] = None,
         explicit_src_folder_path: Optional[str] = None,
+        # ========== QA Parameters ==========
+        log: Optional[Callable[[Any], None]] = None,
+        pbar: Optional[SupportsProgress] = None,  # tqdm
 
         demo: bool = False,
         config: Optional[Any] = None,
 ) -> None:
     """The main function for publishing a package. It performs all necessary steps to prepare and publish the package.
 
+
      :param name: The name of the package.
      :param author: The name of the author.
      :param author_email: The email of the author.
@@ -56,6 +62,8 @@ def publish(
      :param min_python: The minimum Python version required for the package. Defaults to the Python version running this script.
      :param keywords: A list of keywords describing areas of interest for the package. Defaults to None.
      :param dependencies: A list of dependencies for the package. Defaults to None.
+     :param log: A function to receive log statements about the process and print them (or do something else idk)
+     :param pbar: and object that can be notified about an update of progress like a tqdm progress bar.
      :param demo: Whether to perform checks without making any changes. Defaults to False.
      :param config: Reserved for future use. Defaults to None.
 
@@ -70,27 +78,27 @@ def publish(
     min_python = validate_python_version(min_python)  # type:ignore
     keywords = validate_keywords(keywords)
     validated_dependencies: List[Dependency] = validate_dependencies(dependencies)
-
     for enforcer in enforcers or []:
         enforcer.enforce(name=name, version=version, demo=demo)
-
     try:
-        res = qa(
+        res = asyncio.get_event_loop().run_until_complete(qa(
             python_interpreter_provider,
             global_quality_assurance_runners or [],
             name,
             explicit_src_folder_path,
-            validated_dependencies
-        )
+            validated_dependencies,
+            log,
+            pbar
+        ))
         if not res:
             error(f"quickpub.publish exited early as '{name}' "
                   "did not pass quality assurance step, see above "
                   "logs to pass this step.")
-            raise SystemExit(1)
-    except SystemExit as e:
+            raise ExitEarlyError("QA step Failed")
+    except ExitEarlyError as e:
         raise e
     except Exception as e:
-        raise RuntimeError("Quality assurance stage has failed") from e
+        raise RuntimeError("Quality assurance stage has failed", e) from e
 
     create_setup()
     create_toml(

quickpub-3.0.0/quickpub/enforcers.py

@@ -0,0 +1,27 @@
+import sys
+from typing import Union, Callable
+
+from danielutils import error
+
+
+class ExitEarlyError(Exception):
+    pass
+
+
+def exit_if(
+        predicate: Union[bool, Callable[[], bool]],
+        msg: str,
+        *,
+        verbose: bool = True,
+        err_func: Callable[[str], None] = error
+) -> None:
+    if (isinstance(predicate, bool) and predicate) or (callable(predicate) and predicate()):
+        if verbose:
+            err_func(msg)
+        raise ExitEarlyError(msg)
+
+
+__all__ = [
+    "exit_if",
+    "ExitEarlyError",
+]

quickpub-3.0.0/quickpub/qa.py

@@ -0,0 +1,265 @@
+import re
+import sys
+from abc import abstractmethod
+from datetime import datetime
+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  # 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
+
+try:
+    from danielutils import MultiContext  # type:ignore
+except ImportError:
+    class MultiContext(ContextManager):  # type: ignore # pylint: disable=missing-class-docstring
+        def __init__(self, *contexts: ContextManager):
+            self.contexts = contexts
+
+        def __enter__(self):
+            for context in self.contexts:
+                context.__enter__()
+            return self
+
+        def __exit__(self, exc_type, exc_val, exc_tb):
+            for context in self.contexts:
+                context.__exit__(exc_type, exc_val, exc_tb)
+
+        def __getitem__(self, index):
+            return self.contexts[index]
+
+ASYNC_POOL_NAME: str = "Quickpub QA"
+
+
+@runtime_checkable
+class SupportsProgress(Protocol):
+    @abstractmethod
+    def update(self, amount: int) -> None:
+        ...
+
+    @property
+    @abstractmethod
+    def total(self) -> int: ...
+
+    @total.setter
+    @abstractmethod
+    def total(self, amount: int) -> None: ...
+
+
+async def global_import_sanity_check(
+        package_name: str,
+        executor: AsyncLayeredCommand,
+        is_system_interpreter: bool,
+        env_name: str,
+        pbar: Optional[SupportsProgress] = None
+) -> None:
+    """
+    Will check that importing from the package works as a sanity check.
+    :param package_name: Name of the package
+    :param executor: the previously ued AsyncLayeredCommand executor
+    :param is_system_interpreter: whether or not the system interpreter is used
+    :param env_name: The name of the currently tested environment
+    :return: None
+    """
+    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}"
+            code, stdout, stderr = await executor(cmd)
+            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,
+                verbose=True,
+                err_func=lambda msg: None  # TODO remove
+            )
+    finally:
+        if pbar is not None:
+            pbar.update(1)
+
+
+VERSION_REGEX: re.Pattern = re.compile(r"^\d+\.\d+\.\d+$")
+
+
+async def validate_dependencies(
+        validation_exit_on_fail: bool,
+        required_dependencies: List[Dependency],
+        executor: AsyncLayeredCommand,
+        env_name: str,
+        pbar: Optional[SupportsProgress] = None
+) -> None:
+    """
+    will check if all the dependencies of the package are installed on current env.
+    :param validation_exit_on_fail:
+    :param required_dependencies: the dependencies to check
+    :param executor: the current AsyncLayeredCommand executor
+    :param env_name: name of the currently checked environment
+    :return: None
+    """
+    try:
+        if validation_exit_on_fail:
+            code, out, err = await executor("pip list")
+            exit_if(code != 0, f"Failed executing 'pip list' at env '{env_name}'",
+                    err_func=lambda msg: None  # TODO remove
+                    )
+            split_lines = (line.split(' ') for line in out[2:])
+            version_tuples = [(s[0], s[-1].strip()) for s in split_lines]
+            filtered_tuples = [t for t in version_tuples if VERSION_REGEX.match(t[1])]
+            currently_installed: Dict[str, Union[str, Dependency]] = {
+                s[0]: Dependency(s[0], "==", Version.from_str(s[-1]))
+                for s in filtered_tuples}
+            currently_installed.update(**{t[0]: t[1] for t in version_tuples if not VERSION_REGEX.match(t[1])})
+            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"))
+
+            exit_if(bool(not_installed_properly),
+                    f"On env '{env_name}' the following dependencies have problems: {(not_installed_properly)}",
+                    err_func=lambda msg: None  # TODO remove
+                    )
+    finally:
+        if pbar is not None:
+            pbar.update(1)
+
+
+is_config_run_success: List[bool] = []
+
+
+async def run_config(
+        env_name: str,
+        async_executor: AsyncLayeredCommand,
+        runner: QualityAssuranceRunner,
+        config_id: int,
+        *,
+        is_system_interpreter: bool,
+        validation_exit_on_fail: bool,
+        src_folder_path: str,
+        pbar: Optional[SupportsProgress] = None
+) -> None:
+    try:
+        await runner.run(
+            src_folder_path,
+            async_executor,
+            use_system_interpreter=is_system_interpreter,
+            env_name=env_name
+        )
+    except ExitEarlyError as e:
+        raise e
+    except Exception as e:
+        if validation_exit_on_fail:
+            raise RuntimeError(e) from e
+        return
+    finally:
+        if pbar is not None:
+            pbar.update(1)
+    is_config_run_success[config_id] = True
+
+
+async def qa(
+        python_provider: PythonProvider,
+        quality_assurance_strategies: List[QualityAssuranceRunner],
+        package_name: str,
+        src_folder_path: str,
+        dependencies: list,
+        log: Optional[Callable[[Any], None]] = None,
+        pbar: Optional[SupportsProgress] = None
+) -> bool:
+    is_config_run_success.clear()
+    from .strategies import DefaultPythonProvider
+    is_system_interpreter = isinstance(python_provider, DefaultPythonProvider)
+
+    class MyAsyncWorkerPool(AsyncWorkerPool):
+        @classmethod
+        def log(
+                self,
+                level: Literal["INFO", "WARNING", "ERROR"],
+                message: str,
+                order: Optional[List[str]] = AsyncWorkerPool.DEFAULT_ORDER_IF_KEY_EXISTS,
+                **kwargs
+        ) -> None:
+            kwargs["level"] = level
+            kwargs["message"] = message
+            kwargs["timestamp"] = datetime.now().isoformat()
+            ordered_kwargs = kwargs
+            if order:
+                ordered_kwargs = {key: kwargs[key] for key in order if key in kwargs}
+                ordered_kwargs.update(kwargs)
+
+            if log:
+                log(ordered_kwargs)
+
+    pool = MyAsyncWorkerPool(ASYNC_POOL_NAME, num_workers=5)
+    total = 0
+    i = 0
+    with AsyncLayeredCommand() as base:
+        async for env_name, async_executor in python_provider:
+            with async_executor:
+                async_executor.prev = base
+                await pool.submit(
+                    validate_dependencies,
+                    args=[
+                        python_provider.exit_on_fail,
+                        dependencies,
+                        async_executor,
+                        env_name,
+                        pbar
+                    ],
+                    name=f"Validate dependencies for env '{env_name}'",
+                )
+                total += 1
+                await pool.submit(
+                    global_import_sanity_check,
+                    args=[
+                        package_name,
+                        async_executor,
+                        is_system_interpreter,
+                        env_name,
+                        pbar
+                    ],
+                    name=f"Global Import Sanity Check for env '{env_name}'",
+                )
+                total += 1
+                for runner in quality_assurance_strategies:
+                    await pool.submit(
+                        run_config,
+                        args=[env_name, async_executor, runner, i],
+                        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
+                    i += 1
+    if pbar is not None:
+        pbar.total = total
+    for _ in range(i):
+        is_config_run_success.append(False)
+    await pool.start()
+    await pool.join()
+
+    return all(is_config_run_success)
+
+
+__all__ = [
+    'qa',
+    "SupportsProgress"
+]

{quickpub-2.0.4 → quickpub-3.0.0}/quickpub/strategies/constraint_enforcer.py

@@ -1,11 +1,12 @@
 from abc import abstractmethod
 from typing import Type
 
+from ..enforcers import ExitEarlyError
 from .quickpub_strategy import QuickpubStrategy
 
 
 class ConstraintEnforcer(QuickpubStrategy):
-    EXCEPTION_TYPE: Type[BaseException] = SystemExit
+    EXCEPTION_TYPE: Type[Exception] = ExitEarlyError
 
     @abstractmethod
     def enforce(self, **kwargs) -> None: ...

{quickpub-2.0.4 → quickpub-3.0.0}/quickpub/strategies/implementations/constraint_enforcers/pypi_remote_version_enforcer.py

@@ -22,15 +22,16 @@ class PypiRemoteVersionEnforcer(ConstraintEnforcer):
         executor: RetryExecutor[Response] = RetryExecutor(ConstantBackOffStrategy(1))
         response = executor.execute(wrapper, 5)
         if response is None:
-            raise SystemExit(self._HTTP_FAILED_MESSAGE)
+            raise self.EXCEPTION_TYPE(self._HTTP_FAILED_MESSAGE)
         html = response.content.decode()
         i = html.index(f" {name} ")
         try:
             remote_version = Version.from_str(html[i:i + 50].splitlines()[0].strip().split()[1])
         except Exception as e:
-            raise SystemExit(f"{self.__class__.__name__} encountered an unexpected error while parsing.") from e
+            raise self.EXCEPTION_TYPE(f"{self.__class__.__name__} encountered an unexpected error while parsing.",
+                                      e) from e
         if not version > remote_version:
-            raise SystemExit(
+            raise self.EXCEPTION_TYPE(
                 f"Specified version is '{version}' but (remotely available) latest existing is '{remote_version}'")
 
 

{quickpub-2.0.4 → quickpub-3.0.0}/quickpub/strategies/implementations/constraint_enforcers/pypirc_enforcer.py

@@ -15,7 +15,7 @@ class PypircEnforcer(ConstraintEnforcer):
 
     def enforce(self, **kwargs) -> None:
         if not file_exists(self.path):
-            raise SystemExit(f"Couldn't find '{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()

quickpub-3.0.0/quickpub/strategies/implementations/python_providers/conda_python_provider.py

@@ -0,0 +1,35 @@
+from typing import Tuple, Optional, Set, List
+from danielutils import AsyncLayeredCommand
+
+from ....enforcers import ExitEarlyError
+from ...python_provider import PythonProvider
+
+
+class CondaPythonProvider(PythonProvider):
+    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
+
+    @classmethod
+    async def _get_available_envs_impl(cls) -> Set[str]:
+        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]
+        if name not in available_envs:
+            raise ExitEarlyError(f"Can't find env '{name}' in list of conda environments, try 'conda env list'")
+        return name, AsyncLayeredCommand(f"conda activate {name}")
+
+
+__all__ = [
+    'CondaPythonProvider',
+]

{quickpub-2.0.4 → quickpub-3.0.0}/quickpub/strategies/implementations/python_providers/default_python_provider.py

@@ -1,11 +1,17 @@
 import sys
-from typing import Set, Tuple, Iterator
+from typing import Set, Tuple, Iterator, AsyncIterator, Iterable
 
 from danielutils import LayeredCommand
+from danielutils.async_.async_layered_command import AsyncLayeredCommand
 
 from ...python_provider import PythonProvider
 
 
+async def cast_aiter(itr: Iterable) -> AsyncIterator:
+    for x in itr:
+        yield x
+
+
 class DefaultPythonProvider(PythonProvider):
     def get_python_executable_name(self) -> str:
         return sys.executable
@@ -13,8 +19,11 @@ class DefaultPythonProvider(PythonProvider):
     def __init__(self) -> None:
         PythonProvider.__init__(self, requested_envs=["system"], explicit_versions=[], exit_on_fail=True)
 
-    def __iter__(self) -> Iterator[Tuple[str, LayeredCommand]]:
-        return iter([("system", LayeredCommand())])
+    async def __anext__(self):
+        if self.aiter_index == 0:
+            self.aiter_index += 1
+            return "system", AsyncLayeredCommand()
+        raise StopAsyncIteration
 
     @classmethod
     def _get_available_envs_impl(cls) -> Set[str]:

{quickpub-2.0.4 → quickpub-3.0.0}/quickpub/strategies/implementations/quality_assurance_runners/mypy_qa_runner.py

@@ -3,6 +3,7 @@ from typing import Optional, List
 
 from danielutils import LayeredCommand
 
+from ....enforcers import ExitEarlyError
 from ...quality_assurance_runner import QualityAssuranceRunner
 
 
@@ -34,14 +35,20 @@ class MypyRunner(QualityAssuranceRunner):
             return 0.0
 
         if rating_line.endswith("No module named mypy"):
-            raise SystemExit("Mypy is not installed.")
+            raise ExitEarlyError("Mypy is not installed.")
+
+        if rating_line.startswith("mypy: error: Cannot find config file"):
+            raise ExitEarlyError(rating_line)
 
         if rating_line.startswith("Success"):
             return 0.0
 
-        exit_if(not (m := self.RATING_PATTERN.match(rating_line)),
-                f"Failed running MyPy, got exit code {ret}. try running manually using: {self._build_command('TARGET')}",
-                verbose=verbose)
+        exit_if(
+            not (m := self.RATING_PATTERN.match(rating_line)),
+            f"Failed running MyPy, got exit code {ret}. try running manually using: {self._build_command('TARGET')}",
+            verbose=verbose,
+            err_func=lambda msg: None  # TODO remove
+        )
         num_failed = float(m.group(1))  # type :ignore
         # active_files = float(m.group(2))  # type :ignore
         # total_files = float(m.group(3))  # type :ignore

{quickpub-2.0.4 → quickpub-3.0.0}/quickpub/strategies/implementations/quality_assurance_runners/pylint_qa_runner.py

@@ -3,6 +3,7 @@ from typing import Optional, List
 
 from danielutils import LayeredCommand
 
+from ....enforcers import ExitEarlyError
 from ...quality_assurance_runner import QualityAssuranceRunner
 
 
@@ -31,8 +32,12 @@ class PylintRunner(QualityAssuranceRunner):
             return 1
         if len(lines) == 1:
             if lines[0].endswith("No module named pylint"):
-                raise SystemExit("No module named pylint found")
-            raise SystemExit("Got an unexpected error!")
+                raise ExitEarlyError("No module named pylint found")
+
+            if lines[0].startswith("The config file") and lines[0].endswith("doesn't exist!"):
+                raise ExitEarlyError(lines[0])
+
+            raise ExitEarlyError(f"Got an unexpected error: {lines[0]}")
         index = -2
         if lines[-1] == '\x1b[0m':
             index += -1

{quickpub-2.0.4 → quickpub-3.0.0}/quickpub/strategies/implementations/quality_assurance_runners/pytest_qa_runner.py

@@ -4,7 +4,8 @@ from typing import List, Union
 
 from danielutils import LayeredCommand
 
-from quickpub import Bound
+from ....enforcers import ExitEarlyError
+from ....structures import Bound
 from ...quality_assurance_runner import QualityAssuranceRunner
 
 
@@ -85,7 +86,7 @@ class PytestRunner(QualityAssuranceRunner):
         if "no tests ran" in rating_line:
             return self.no_tests_score
         if not (m := self.PYTEST_REGEX.match(rating_line)):
-            raise SystemExit(1)
+            raise ExitEarlyError(f"Can't calculate score for pytest on the following line: {rating_line}")
 
         dct = m.groupdict()
         failed = int(dct["failed"] or "0")

{quickpub-2.0.4 → quickpub-3.0.0}/quickpub/strategies/implementations/quality_assurance_runners/unittest_qa_runner.py

@@ -1,8 +1,10 @@
 import re
 import os
+from pathlib import Path
 from typing import Optional, List
 from danielutils import get_current_working_directory, set_current_working_directory, LayeredCommand, warning
 
+from ....enforcers import ExitEarlyError
 from ...quality_assurance_runner import QualityAssuranceRunner
 
 
@@ -24,26 +26,23 @@ class UnittestRunner(QualityAssuranceRunner):
     def _install_dependencies(self, base: LayeredCommand) -> None:
         return None
 
-    def _pre_command(self):
-        self._cwd = get_current_working_directory()
-        if self.target is None:
-            self.target = ""
-            warning("This is not supposed to happen. See quickpub's UnitestRunner._pre_command")
-        set_current_working_directory(os.path.join(self._cwd, self.target))
+    def _pre_command(self) -> None:
+        pass
 
     def _post_command(self):
-        set_current_working_directory(self._cwd)
+        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._cwd = ""
         self.no_tests_score = no_tests_score
 
     def _build_command(self, src: str, *args, use_system_interpreter: bool = False) -> str:
         command: str = self.get_executable()
         rel = _removesuffix(os.path.relpath(src, self.target), src.lstrip("./\\"))
         command += f" discover -s {rel}"
-        return command  # f"cd {self.target}; {command}"  # f"; cd {self.target}"
+        normalized_target_path = Path(os.path.join(os.getcwd(), self.target)).resolve()
+        return f"cd {normalized_target_path} & {command} & cd {Path(os.getcwd()).resolve()}"  # This is for concurrency reasons
 
     def _calculate_score(self, ret: int, lines: List[str], *, verbose: bool = False) -> float:
         num_tests_ran_line = lines[-3]
@@ -61,8 +60,8 @@ class UnittestRunner(QualityAssuranceRunner):
             return 1 - ((num_failed + num_errors) / num_tests)
 
         except Exception as e:
-            raise SystemExit(f"Failed running Unittest, got exit code {ret}. "
-                             f"try running manually using: {self._build_command('TARGET')}") from e
+            raise ExitEarlyError(f"Failed running Unittest, got exit code {ret}. "
+                                 f"try running manually using: {self._build_command('TARGET')}") from e
 
 
 __all__ = [

quickpub-3.0.0/quickpub/strategies/python_provider.py

@@ -0,0 +1,55 @@
+import asyncio
+
+from .quickpub_strategy import QuickpubStrategy
+from abc import abstractmethod
+from typing import Tuple, Set, List, AsyncIterator, Iterator, Iterable
+from danielutils.async_.async_layered_command import AsyncLayeredCommand
+
+
+class PythonProvider(AsyncIterator, QuickpubStrategy):
+    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]: ...
+
+    @classmethod
+    async def get_available_envs(cls) -> Set[str]:
+        KEY = "__available_envs__"
+        if (res := getattr(cls, KEY, None)) is not None:
+            return res
+
+        setattr(cls, KEY, res := await cls._get_available_envs_impl())
+        return res
+
+    @classmethod
+    @abstractmethod
+    async def _get_available_envs_impl(cls) -> Set[str]:
+        ...
+
+    def __len__(self) -> int:
+        return len(self.requested_envs)
+
+    @abstractmethod
+    def get_python_executable_name(self) -> str:
+        ...
+
+
+__all__ = [
+    'PythonProvider'
+]

{quickpub-2.0.4 → quickpub-3.0.0}/quickpub/strategies/quality_assurance_runner.py

@@ -2,6 +2,7 @@ import sys
 from abc import abstractmethod
 from typing import Union, List, Optional, cast, Dict, Tuple
 from danielutils import LayeredCommand, get_os, OSType, file_exists
+from danielutils.async_.async_layered_command import AsyncLayeredCommand
 
 from quickpub import Bound
 
@@ -124,8 +125,8 @@ class QualityAssuranceRunner(Configurable, HasOptionalExecutable):
         """
         pass
 
-    def run(self, target: str, executor: LayeredCommand, *, verbose: bool = True,  # type: ignore
-            use_system_interpreter: bool = False, print_func, env_name: str) -> None:
+    async def run(self, target: str, executor: AsyncLayeredCommand, *, verbose: bool = True,  # type: ignore
+                  use_system_interpreter: bool = False, env_name: str) -> None:
         """
         Runs the QA process on the specified target.
 
@@ -133,31 +134,34 @@ class QualityAssuranceRunner(Configurable, HasOptionalExecutable):
         :param executor: The executor object to run the command.
         :param verbose: Whether to output verbose logs, default is True.
         :param use_system_interpreter: Whether to use the system interpreter, default is False.
-        :param print_func: The function to use for printing output.
         :param env_name: The name of the environment in which the QA runner is executed.
         """
         from quickpub.proxy import os_system  # pylint: disable=import-error
         from quickpub.enforcers import exit_if  # pylint: disable=import-error
         # =====================================
         # IMPORTANT: need to explicitly override it here
-        executor._executor = os_system  # pylint: disable=protected-access
+        # executor._executor = os_system  # pylint: disable=protected-access #TODO re-fix this for the tests because now this is not working with the async variant
         # =====================================
         command = self._build_command(target, use_system_interpreter)
         self._pre_command()
         try:
-            ret, out, err = executor(command, command_raise_on_fail=False)
+            ret, out, err = await executor(command, command_raise_on_fail=False)
             if ret in SPEICLA_EXIT_CODES:
                 title, explanation = SPEICLA_EXIT_CODES[ret]
                 unsigned_integer_ret = ret + 2 ** 32
                 raise RuntimeError(
                     title + "\n\t" + explanation.format(command=command, ret=ret, hex=hex(unsigned_integer_ret)))
-            score = self._calculate_score(ret, "".join(out + err).splitlines(), verbose=verbose)
-            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}",
-                    verbose=verbose, err_func=print_func)
+            score = self._calculate_score(ret, out + err, verbose=verbose)
+            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}",
+                verbose=verbose,
+                err_func=lambda msg: None  # TODO remove
+            )
         except Exception as e:
             raise RuntimeError(
-                f"On env {env_name}, failed to run {self.__class__.__name__}. Try running manually:\n{executor._build_command(command)}") from e
+                f"On env {env_name}, failed to run {self.__class__.__name__}. Try running manually:\n{executor._build_command(command)}",
+                e) from e
         finally:
             self._post_command()
 

{quickpub-2.0.4 → quickpub-3.0.0}/quickpub/strategies/quickpub_strategy.py

@@ -2,9 +2,11 @@ from typing import Type
 
 from danielutils.university.oop.strategy import Strategy
 
+from ..enforcers import ExitEarlyError
+
 
 class QuickpubStrategy(Strategy):
-    EXCEPTION_TYPE: Type[Exception] = SystemExit
+    EXCEPTION_TYPE: Type[Exception] = ExitEarlyError
 
 
 __all__ = [

{quickpub-2.0.4 → quickpub-3.0.0}/quickpub/validators.py

@@ -2,12 +2,13 @@ from typing import Optional, Union, List
 
 from danielutils import get_python_version
 
+from .enforcers import ExitEarlyError
 from .structures import Version, Dependency
 
 
 def validate_version(version: Optional[Union[str, Version]] = None) -> Version:
-    if version is None:
-        return Version(0, 0, 1)
+    if not bool(version):
+        raise ExitEarlyError(f"Must supply a version number. got '{version}'")
     return version if isinstance(version, Version) else Version.from_str(version)  # type: ignore
 
 
@@ -45,5 +46,6 @@ __all__ = [
     "validate_version",
     "validate_python_version",
     "validate_keywords",
-    "validate_dependencies"
+    "validate_dependencies",
+    "validate_source"
 ]

{quickpub-2.0.4 → quickpub-3.0.0/quickpub.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: quickpub
-Version: 2.0.4
+Version: 3.0.0
 Summary: A python package to quickly configure and publish a new package
 Author-email: danielnachumdev <danielnachumdev@gmail.com>
 License: MIT License
@@ -33,8 +33,12 @@ Classifier: Operating System :: Microsoft :: Windows
 Requires-Python: >=3.8.0
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: danielutils>=1.0.0
+Requires-Dist: requests
+Requires-Dist: fire
+Dynamic: license-file
 
-# quickpub V2.0.2
+# quickpub V3.0.0
 **Tested python versions**: `3.8.0`, `3.9.0`, `3.10.13`,
 
 Example usage of how this package was published

{quickpub-2.0.4 → quickpub-3.0.0}/quickpub.egg-info/SOURCES.txt

@@ -3,6 +3,8 @@ MANIFEST.in
 README.md
 pyproject.toml
 setup.py
+./LICENSE
+./README.md
 quickpub/__init__.py
 quickpub/__main__.py
 quickpub/classifiers.py

quickpub-2.0.4/quickpub/enforcers.py

@@ -1,17 +0,0 @@
-import sys
-from typing import Union, Callable
-
-from danielutils import error
-
-
-def exit_if(predicate: Union[bool, Callable[[], bool]], msg: str, *, verbose: bool = True,
-            err_func: Callable[[str], None] = error) -> None:
-    if (isinstance(predicate, bool) and predicate) or (callable(predicate) and predicate()):
-        if verbose:
-            err_func(msg)
-        sys.exit(1)
-
-
-__all__ = [
-    "exit_if"
-]

quickpub-2.0.4/quickpub/qa.py

@@ -1,180 +0,0 @@
-import re
-import sys
-from functools import wraps
-from typing import Optional, ContextManager, List, Callable, Tuple, Dict, Union
-from danielutils import AttrContext, LayeredCommand, AsciiProgressBar, ColoredText, ProgressBarPool, TemporaryFile
-
-from .strategies import PythonProvider, QualityAssuranceRunner  # pylint: disable=relative-beyond-top-level
-from .structures import Dependency, Version, Bound  # pylint: disable=relative-beyond-top-level
-from .enforcers import exit_if  # pylint: disable=relative-beyond-top-level
-
-try:
-    from danielutils import MultiContext  # type:ignore
-except ImportError:
-    class MultiContext(ContextManager):  # type: ignore # pylint: disable=missing-class-docstring
-        def __init__(self, *contexts: ContextManager):
-            self.contexts = contexts
-
-        def __enter__(self):
-            for context in self.contexts:
-                context.__enter__()
-            return self
-
-        def __exit__(self, exc_type, exc_val, exc_tb):
-            for context in self.contexts:
-                context.__exit__(exc_type, exc_val, exc_tb)
-
-        def __getitem__(self, index):
-            return self.contexts[index]
-
-
-def global_import_sanity_check(package_name: str, executor: LayeredCommand, is_system_interpreter: bool,
-                               env_name: str, err_print_func) -> None:
-    """
-    Will check that importing from the package works as a sanity check.
-    :param package_name: Name of the package
-    :param executor: the previously ued LayeredCommand executor
-    :param is_system_interpreter: whether or not the system interpreter is used
-    :param env_name: The name of the currently tested environment
-    :param err_print_func: the function to print our errors
-    :return: None
-    """
-    p = sys.executable if is_system_interpreter else "python"
-    file_name = "./__sanity_check_main.py"
-    with TemporaryFile(file_name) as f:
-        f.writelines([f"from {package_name} import *"])
-        code, _, _ = executor(f"{p} {file_name}")
-        exit_if(code != 0,
-                f"Env '{env_name}' failed sanity check. "
-                f"Try manually running the following script 'from {package_name} import *'",
-                verbose=True, err_func=err_print_func)
-
-
-VERSION_REGEX: re.Pattern = re.compile(r"^\d+\.\d+\.\d+$")
-
-
-def validate_dependencies(python_manager: PythonProvider, required_dependencies: List[Dependency],
-                          executor: LayeredCommand,
-                          env_name: str, err_print_func: Callable) -> None:
-    """
-    will check if all the dependencies of the package are installed on current env.
-    :param python_manager: the manager to use
-    :param required_dependencies: the dependencies to check
-    :param executor: the current LayeredCommand executor
-    :param env_name: name of the currently checked environment
-    :param err_print_func: function to print errors
-    :return: None
-    """
-    if python_manager.exit_on_fail:
-        code, out, err = executor("pip list")
-        exit_if(code != 0, f"Failed executing 'pip list' at env '{env_name}'", err_func=err_print_func)
-        split_lines = (line.split(' ') for line in out[2:])
-        version_tuples = [(s[0], s[-1].strip()) for s in split_lines]
-        filtered_tuples = [t for t in version_tuples if VERSION_REGEX.match(t[1])]
-        currently_installed: Dict[str, Union[str, Dependency]] = {s[0]: Dependency(s[0], "==", Version.from_str(s[-1]))
-                                                                  for s in filtered_tuples}
-        currently_installed.update(**{t[0]: t[1] for t in version_tuples if not VERSION_REGEX.match(t[1])})
-        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, "Verion format of dependecy 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"))
-
-        exit_if(bool(not_installed_properly),
-                f"On env '{env_name}' the following dependencies have problems: {(not_installed_properly)}",
-                err_func=err_print_func)
-
-
-def create_progress_bar_pool(python_version_manager: PythonProvider,
-                             quality_assurance_strategies: List[QualityAssuranceRunner]) -> ProgressBarPool:
-    return ProgressBarPool(
-        AsciiProgressBar,
-        2,
-        individual_options=[
-            dict(
-                iterator=python_version_manager,
-                desc="Envs",
-                total=len(python_version_manager.requested_envs)
-            ),
-            dict(
-                iterator=quality_assurance_strategies or [],
-                desc="Runners",
-                total=len(quality_assurance_strategies or [])
-            ),
-        ]
-    )
-
-
-def create_pool_print_error(pool: ProgressBarPool):
-    @wraps(pool.write)
-    def func(*args, **kwargs):
-        msg = "".join([ColoredText.red("ERROR"), ": ", *args])
-        pool.write(msg, **kwargs)
-
-    return func
-
-
-def qa(
-        python_provider: PythonProvider,
-        quality_assurance_strategies: List[QualityAssuranceRunner],
-        package_name: str,
-        src_folder_path: str,
-        dependencies: list
-) -> bool:
-    from .strategies import DefaultPythonProvider
-    result = True
-    is_system_interpreter = isinstance(python_provider, DefaultPythonProvider)
-    pool = create_progress_bar_pool(python_provider, quality_assurance_strategies)
-    pool_err = create_pool_print_error(pool)
-    with LayeredCommand() as base:
-        for env_name, executor in pool[0]:
-            pool[0].desc = f"Env '{env_name}'"
-            pool[0].update(0, refresh=True)
-            with executor:
-                executor._prev_instance = base
-                try:
-                    validate_dependencies(python_provider, dependencies, executor, env_name, pool_err)
-                except SystemExit:
-                    result = False
-                    continue
-                try:
-                    global_import_sanity_check(package_name, executor, is_system_interpreter, env_name, pool_err)
-                except SystemExit:
-                    result = False
-                    continue
-                for runner in pool[1]:
-                    pool[1].desc = f"Runner '{runner.__class__.__name__}'"
-                    pool[1].update(0, refresh=True)
-                    try:
-                        runner.run(
-                            src_folder_path,
-                            executor,
-                            use_system_interpreter=is_system_interpreter,
-                            print_func=pool_err,
-                            env_name=env_name
-                        )
-                    except SystemExit:
-                        result = False
-                        continue
-                    except Exception as e:
-                        result = False
-                        manual_command = executor._build_command(runner._build_command(src_folder_path))
-                        pool_err(
-                            f"Failed running '{runner.__class__.__name__}' on env '{env_name}'. "
-                            f"Try manually: '{manual_command}'.")
-                        pool.write(f"\tCaused by '{e.__cause__ or e}'")
-                        if python_provider.exit_on_fail:
-                            raise RuntimeError() from e
-    return result
-
-
-__all__ = [
-    'qa'
-]

quickpub-2.0.4/quickpub/strategies/implementations/python_providers/conda_python_provider.py

@@ -1,32 +0,0 @@
-from typing import Tuple, Optional, Set, Iterator, List
-from danielutils import LayeredCommand, warning
-
-from ...python_provider import PythonProvider
-
-
-class CondaPythonProvider(PythonProvider):
-    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
-
-    @classmethod
-    def _get_available_envs_impl(cls) -> Set[str]:
-        with LayeredCommand() as base:
-            code, out, err = base("conda env list")
-        return set([line.split(' ')[0] for line in out[2:] if len(line.split(' ')) > 1])
-
-    def __iter__(self) -> Iterator[Tuple[str, LayeredCommand]]:
-        available_envs = self.get_available_envs()
-        for name in self.requested_envs:
-            if name not in available_envs:
-                warning(f"Couldn't find env '{name}'")
-                continue
-            yield name, LayeredCommand(f"conda activate {name}")
-
-
-__all__ = [
-    'CondaPythonProvider',
-]

quickpub-2.0.4/quickpub/strategies/python_provider.py

@@ -1,42 +0,0 @@
-from .quickpub_strategy import QuickpubStrategy
-from .quality_assurance_runner import QualityAssuranceRunner
-from abc import abstractmethod
-from typing import Tuple, Set, Iterator, List
-from danielutils import LayeredCommand
-
-
-class PythonProvider(QuickpubStrategy):
-    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
-
-    @abstractmethod
-    def __iter__(self) -> Iterator[Tuple[str, LayeredCommand]]: ...
-
-    @classmethod
-    def get_available_envs(cls) -> Set[str]:
-        KEY = "__available_envs__"
-        if (res := getattr(cls, KEY, None)) is not None:
-            return res
-
-        setattr(cls, KEY, res := cls._get_available_envs_impl())
-        return res
-
-    @classmethod
-    @abstractmethod
-    def _get_available_envs_impl(cls) -> Set[str]: ...
-
-    def __len__(self) -> int:
-        return len(self.requested_envs)
-
-    @abstractmethod
-    def get_python_executable_name(self) -> str: ...
-
-
-__all__ = [
-    'PythonProvider'
-]