quickpub 0.8.3__tar.gz → 1.0.0__tar.gz

{quickpub-0.8.3/quickpub.egg-info → quickpub-1.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: quickpub
-Version: 0.8.3
+Version: 1.0.0
 Summary: A python package to quickly configure and publish a new package
 Author-email: danielnachumdev <danielnachumdev@gmail.com>
 License: MIT License

{quickpub-0.8.3 → quickpub-1.0.0}/pyproject.toml

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

{quickpub-0.8.3 → quickpub-1.0.0}/quickpub/__init__.py

@@ -1,3 +1,4 @@
 from .structures import *
 from .runnables import *
+from .managers import *
 from .__main__ import publish

{quickpub-0.8.3 → quickpub-1.0.0}/quickpub/__main__.py

@@ -1,13 +1,13 @@
 from typing import Optional, Union, List
-from danielutils import warning, file_exists
+from danielutils import warning, file_exists, error
 from .validators import validate_version, validate_python_version, validate_keywords, validate_dependencies, \
     validate_source
-from .functions import build, upload, commit, metrics
+from .functions import build, upload, commit
 from .structures import Version, AdditionalConfiguration
 from .files import create_toml, create_setup, create_manifest
 from .classifiers import *
 from .enforcers import enforce_local_correct_version, enforce_pypirc_exists, exit_if, enforce_remote_correct_version
-from .custom_types import Path
+from .qa import qa
 
 
 def publish(
@@ -17,10 +17,10 @@ def publish(
         author_email: str,
         description: str,
         homepage: str,
-        src: Optional[Path] = None,
+        explicit_src_folder_path: Optional[str] = None,
         version: Optional[Union[Version, str]] = None,
-        readme: Path = "./README.md",
-        license: Path = "./LICENSE",
+        readme_file_path: str = "./README.md",
+        license_file_path: str = "./LICENSE",
 
         min_python: Optional[Union[Version, str]] = None,
 
@@ -36,23 +36,22 @@ def publish(
         author_email (str): The email of the author
         description (str): A short description for the package
         homepage (str): The homepage for the package. URL to the github repo is a good option.
-        src (Optional[Path], optional): The path to the source code of the package. if None defaults to CWD/<name>
+        explicit_src_folder_path (Optional[Path], optional): The path to the source code of the package. if None defaults to CWD/<name>
         version (Optional[Union[Version, str]], optional): The version to create the new distribution. if None defaults to 0.0.1
-        readme (Path, optional): The path to the readme file. Defaults to "./README.md".
-        license (Path, optional): The path to the license file . Defaults to "./LICENSE".
+        readme_file_path (Path, optional): The path to the readme file. Defaults to "./README.md".
+        license_file_path (Path, optional): The path to the license file . Defaults to "./LICENSE".
         min_python (Optional[Union[Version, str]], optional): The minimum version of python required for this package to run. Defaults to the version of python running this script.
         keywords (Optional[list[str]], optional): A list of keywords to describe areas of interests of this package. Defaults to None.
         dependencies (Optional[list[str]], optional): A list of the dependencies for this package. Defaults to None.
         config (Optional[Config], optional): reserved for future use. Defaults to None.
     """
     enforce_pypirc_exists()
-    src = validate_source(name, src)
-    if src != f"./{name}":
+    explicit_src_folder_path = validate_source(name, explicit_src_folder_path)
+    if explicit_src_folder_path != f"./{name}":
         warning(
             "The source folder's name is different from the package's name. this may not be currently supported correctly")
-    exit_if(not file_exists(readme), f"Could not find readme file at {readme}")
-    exit_if(not file_exists(license),
-            f"Could not find license file at {license}")
+    exit_if(not file_exists(readme_file_path), f"Could not find readme file at {readme_file_path}")
+    exit_if(not file_exists(license_file_path), f"Could not find license file at {license_file_path}")
     version = validate_version(version)
     enforce_local_correct_version(name, version)
     min_python = validate_python_version(min_python)  # type:ignore
@@ -60,17 +59,22 @@ def publish(
     dependencies = validate_dependencies(dependencies)
     enforce_remote_correct_version(name, version)
 
-    if config is not None:
-        if config.runners is not None:
-            for runner in config.runners:
-                runner.run(src)
+    try:
+        if not qa(name, config, explicit_src_folder_path, dependencies):
+            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 e
+    except Exception as e:
+        raise RuntimeError("Quality assurance stage has failed") from e
 
     create_setup()
     create_toml(
         name=name,
-        src=src,
-        readme=readme,
-        license=license,
+        src_folder_path=explicit_src_folder_path,
+        readme_file_path=readme_file_path,
+        license_file_path=license_file_path,
         version=version,
         author=author,
         author_email=author_email,
@@ -96,7 +100,6 @@ def publish(
     commit(
         version=version
     )
-    metrics()
 
 # if __name__ == '__main__':
 #     publish()

{quickpub-0.8.3 → quickpub-1.0.0}/quickpub/enforcers.py

@@ -1,16 +1,15 @@
 import sys
 from typing import Union, Callable
 
-import requests
-# from bs4 import BeautifulSoup
 from danielutils import directory_exists, get_files, error, file_exists, get_python_version
 from .structures import Version
-from .proxy import get
 
 
-def exit_if(predicate: Union[bool, Callable[[], bool]], msg: str) -> None:
+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()):
-        error(msg)
+        if verbose:
+            err_func(msg)
         sys.exit(1)
 
 

{quickpub-0.8.3 → quickpub-1.0.0}/quickpub/files.py

@@ -1,6 +1,5 @@
 from typing import List
 from danielutils import get_files
-from .custom_types import Path
 from .classifiers import Classifier
 from .structures import Version
 
@@ -8,9 +7,9 @@ from .structures import Version
 def create_toml(
         *,
         name: str,
-        src: Path,
-        readme: Path,
-        license: Path,
+        src_folder_path: str,
+        readme_file_path: str,
+        license_file_path: str,
         version: Version,
         author: str,
         author_email: str,
@@ -25,7 +24,7 @@ def create_toml(
     if len(classifiers_string) > 0:
         classifiers_string = f"\n\t{classifiers_string}\n"
     py_typed = ""
-    for file in get_files(src):
+    for file in get_files(src_folder_path):
         if file == "py.typed":
             py_typed = f"""[tool.setuptools.package-data]
 "{name}" = ["py.typed"]"""
@@ -43,9 +42,9 @@ authors = [
 ]
 dependencies = {dependencies}
 keywords = {keywords}
-license = {{ "file" = "{license}" }}
+license = {{ "file" = "{license_file_path}" }}
 description = "{description}"
-readme = {{file = "{readme}", content-type = "text/markdown"}}
+readme = {{file = "{readme_file_path}", content-type = "text/markdown"}}
 requires-python = ">={min_python}"
 classifiers = [{classifiers_string}]
 

{quickpub-0.8.3 → quickpub-1.0.0}/quickpub/functions.py

@@ -7,8 +7,6 @@ from .structures import Version
 import quickpub.proxy
 
 
-
-
 def prev_main():
     import re
     from danielutils import cmrt, cm, read_file, get_files, directory_exists, create_directory  # type:ignore
@@ -204,13 +202,8 @@ def commit(
     )
 
 
-def metrics(testing_client: Optional[Literal["pytest", "unitest"]] = None):
-    pass
-
-
 __all__ = [
     "build",
     "upload",
     "commit",
-    "metrics"
 ]

quickpub-1.0.0/quickpub/managers/__init__.py

@@ -0,0 +1,2 @@
+from .python_manager import *
+from .implementations import *

quickpub-1.0.0/quickpub/managers/implementations/__init__.py

@@ -0,0 +1,2 @@
+from .conda import *
+from .system_interpreter import *

quickpub-1.0.0/quickpub/managers/implementations/conda.py

@@ -0,0 +1,37 @@
+from typing import Tuple, Optional, Set, Iterator
+from danielutils import LayeredCommand, warning
+
+from ..python_manager import PythonManager
+
+
+class CondaPythonManager(PythonManager):
+    def get_python_executable_name(self) -> str:
+        return "python"
+
+    def __init__(self, env_names: list[str]) -> None:
+        PythonManager.__init__(self, requested_envs=env_names, explicit_versions=[])
+        self._cached_available_envs: Optional[Set[str]] = None
+
+    def get_available_envs(self) -> Set[str]:
+        if self._cached_available_envs is not None:
+            return self._cached_available_envs
+
+        with LayeredCommand(instance_flush_stdout=False, instance_flush_stderr=False) as base:
+            code, out, err = base("conda env list")
+        res = set([line.split(' ')[0] for line in out[2:] if len(line.split(' ')) > 1])
+
+        self._cached_available_envs = res
+        return res
+
+    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__ = [
+    'CondaPythonManager',
+]

quickpub-1.0.0/quickpub/managers/implementations/system_interpreter.py

@@ -0,0 +1,25 @@
+import sys
+from typing import Set, Tuple, Iterator
+
+from danielutils import LayeredCommand
+
+from .. import PythonManager
+
+
+class SystemInterpreter(PythonManager):
+    def get_python_executable_name(self) -> str:
+        return sys.executable
+
+    def __init__(self) -> None:
+        PythonManager.__init__(self, requested_envs=["system"], explicit_versions=[], exit_on_fail=True)
+
+    def __iter__(self) -> Iterator[Tuple[str, LayeredCommand]]:
+        return iter([("system", LayeredCommand(""))])
+
+    def get_available_envs(self) -> Set[str]:
+        return set("system")
+
+
+__all__ = [
+    "SystemInterpreter",
+]

quickpub-1.0.0/quickpub/managers/python_manager.py

@@ -0,0 +1,30 @@
+from abc import ABC, abstractmethod
+from typing import Tuple, Set, Iterator
+from danielutils import LayeredCommand
+
+
+class PythonManager(ABC):
+    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]]: ...
+
+    @abstractmethod
+    def get_available_envs(self) -> Set[str]: ...
+
+    def __len__(self) -> int:
+        return len(self.requested_envs)
+
+    @abstractmethod
+    def get_python_executable_name(self) -> str: ...
+
+
+__all__ = [
+    'PythonManager'
+]

{quickpub-0.8.3 → quickpub-1.0.0}/quickpub/proxy.py

@@ -1,6 +1,7 @@
+import os
+from typing import Tuple
 import danielutils
 import requests
-from typing import Tuple
 
 
 # need it like this for the testing
@@ -8,20 +9,16 @@ def cm(*args, **kwargs) -> Tuple[int, bytes, bytes]:
     return danielutils.cm(*args, **kwargs)
 
 
-def get(*args, **kwargs):
-    return requests.get(*args, **kwargs)
+def os_system(command) -> int:
+    return os.system(command)
 
 
-def add_verbose_keyword(func):
-    def wrapper(*args, verbose: bool = False, **kwargs):
-        if verbose:
-            return func(*args, **kwargs)
-
-    return wrapper
+def get(*args, **kwargs):
+    return requests.get(*args, **kwargs)
 
 
 __all__ = [
     "cm",
-    "get",
-    'add_verbose_keyword'
+    'os_system',
+    "get"
 ]

quickpub-1.0.0/quickpub/qa.py

@@ -0,0 +1,159 @@
+import sys
+from functools import wraps
+from typing import Optional, ContextManager, List, Callable
+from danielutils import AttrContext, LayeredCommand, AsciiProgressBar, ColoredText, ProgressBarPool, TemporaryFile
+
+from .managers import PythonManager  # pylint: disable=relative-beyond-top-level
+from .structures import AdditionalConfiguration  # 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):  # pylint: disable=missing-class-docstring #type:ignore
+        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.write([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)
+
+
+def validate_dependencies(python_manager: PythonManager, dependencies: List[str], 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 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)
+        installed = [line.split(' ')[0] for line in out[2:]]
+        not_installed = []
+        for dep in dependencies:
+            if dep not in installed:
+                not_installed.append(dep)
+        exit_if(not (len(not_installed) == 0),
+                f"On env '{env_name}' the following dependencies are not installed: {not_installed}",
+                err_func=err_print_func)
+
+
+def create_progress_bar_pool(config, python_manager) -> ProgressBarPool:
+    return ProgressBarPool(
+        AsciiProgressBar,
+        2,
+        individual_options=[
+            dict(iterable=python_manager, desc="Envs", total=len(python_manager.requested_envs)),
+            dict(iterable=config.runners or [], desc="Runners", total=len(config.runners 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(package_name: str, config: Optional[AdditionalConfiguration], src_folder_path: Optional[str],
+       dependencies: list) -> bool:
+    if config is None:
+        return True
+    result = True
+    python_manager = config.python_manager
+    is_system_interpreter: bool = False
+    if python_manager is None:
+        from .managers import SystemInterpreter
+        python_manager = SystemInterpreter()
+        is_system_interpreter = True
+    pool = create_progress_bar_pool(config, python_manager)
+    pool_err = create_pool_print_error(pool)
+    with MultiContext(
+            AttrContext(LayeredCommand, 'class_flush_stdout', False),
+            AttrContext(LayeredCommand, 'class_flush_stderr', False),
+            AttrContext(LayeredCommand, 'class_raise_on_fail', False),
+            base := LayeredCommand()
+    ):
+        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_manager, 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,
+                            raise_on_fail=python_manager.exit_on_fail,
+                            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_manager.exit_on_fail:
+                            raise e
+    return result
+
+
+__all__ = [
+    'qa'
+]

quickpub-1.0.0/quickpub/runnables/base_runner.py

@@ -0,0 +1,65 @@
+from abc import abstractmethod
+from typing import Optional, Union, List
+
+from danielutils import LayeredCommand
+
+from .has_optional_executable import HasOptionalExecutable
+from .runnable import Runnable
+from .configurable import Configurable
+from ..structures import Bound
+from ..proxy import os_system
+
+
+class BaseRunner(Runnable, 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, auto_install: bool = False) -> None:
+        Configurable.__init__(self, configuration_path)
+        HasOptionalExecutable.__init__(self, name, executable_path)
+        self.bound: Bound = bound if isinstance(bound, Bound) else Bound.from_string(bound)
+        self.target = 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:
+        pass
+
+    def _post_command(self) -> None:
+        pass
+
+    def run(self, target: str, executor: LayeredCommand, *_, verbose: bool = True,  # type: ignore
+            use_system_interpreter: bool = False, raise_on_fail: bool = False, print_func, env_name: str) -> None:
+        # =====================================
+        # IMPORTANT: need to explicitly override it here
+        executor._executor = os_system
+        # =====================================
+        command = self._build_command(target, use_system_interpreter)
+        self._pre_command()
+        try:
+            ret, out, err = executor(command, command_raise_on_fail=raise_on_fail)
+            score = self._calculate_score(ret, "".join(out + err).splitlines(), verbose=verbose)
+            from ..enforcers import exit_if
+            exit_if(not self.bound.compare_against(score),
+                    f"On env '{env_name}' runner '{self.__class__.__name__}' failed to pass it's defined bound. Got a score of {score} but expected {self.bound}",
+                    verbose=verbose, err_func=print_func)
+        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
+        finally:
+            self._post_command()
+
+    @abstractmethod
+    def _calculate_score(self, ret: int, command_output: List[str], *, verbose: bool = False) -> float:
+        ...
+
+
+__all__ = [
+    "BaseRunner"
+]

{quickpub-0.8.3 → quickpub-1.0.0}/quickpub/runnables/has_optional_executable.py

@@ -1,4 +1,5 @@
-from typing import Any, Protocol, Optional
+import sys
+from typing import Any, Protocol, Optional, cast
 from danielutils import get_os, OSType, file_exists
 
 
@@ -16,10 +17,14 @@ class HasOptionalExecutable():
             if not file_exists(self.executable_path):
                 raise FileNotFoundError(f"Executable not found {self.executable_path}")
 
-    def get_executable(self) -> str:
+    def get_executable(self, use_system_interpreter: bool = False) -> str:
         if self.use_executable:
-            return self.executable_path
-        return f"{self.PYTHON} -m {self.name}"
+            return cast(str, self.executable_path)
+
+        p = self.PYTHON
+        if use_system_interpreter:
+            p = sys.executable
+        return f"{p} -m {self.name}"
 
 
 __all__ = [

quickpub-1.0.0/quickpub/runnables/implementations/mypy.py

@@ -0,0 +1,45 @@
+import re
+from typing import Optional, List
+
+from danielutils import LayeredCommand
+
+from ..base_runner import BaseRunner
+
+
+class MypyRunner(BaseRunner):
+    def _install_dependencies(self, base: LayeredCommand) -> None:
+        with base:
+            base("pip install pylint")
+
+    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
+
+    RATING_PATTERN: re.Pattern = re.compile(
+        "Found (\d+(?:\.\d+)?) errors in (\d+(?:\.\d+)?) files \(checked (\d+(?:\.\d+)?) source files\)")
+
+    def __init__(self, bound: str = "<15", configuration_path: Optional[str] = None,
+                 executable_path: Optional[str] = None) -> None:
+        BaseRunner.__init__(self, name="mypy", bound=bound, configuration_path=configuration_path,
+                            executable_path=executable_path)
+
+    def _calculate_score(self, ret, lines: List[str], verbose: bool = False) -> float:
+        from ...enforcers import exit_if
+        rating_line = lines[-1]
+        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:\n\t{self._build_command('TARGET')}",
+                verbose=verbose)
+        num_failed = float(m.group(1))
+        active_files = float(m.group(2))
+        total_files = float(m.group(3))
+        return num_failed
+
+
+__all__ = [
+    'MypyRunner',
+]

quickpub-1.0.0/quickpub/runnables/implementations/pylint.py

@@ -0,0 +1,43 @@
+import re
+from typing import Optional, List
+
+from danielutils import LayeredCommand
+
+from ..base_runner import BaseRunner
+
+
+class PylintRunner(BaseRunner):
+    def _install_dependencies(self, base: LayeredCommand) -> None:
+        with base:
+            base("pip install pylint")
+
+    RATING_PATTERN: re.Pattern = re.compile(r".*?([\d\.\/]+)")
+
+    def __init__(self, bound: str = ">=0.8", configuration_path: Optional[str] = None,
+                 executable_path: Optional[str] = None) -> None:
+        BaseRunner.__init__(self, name="pylint", bound=bound, configuration_path=configuration_path,
+                            executable_path=executable_path)
+
+    def _build_command(self, target: str, use_system_interpreter: bool = False) -> str:
+        command: str = self.get_executable()
+        if self.has_config:
+            command += f" --rcfile {self.config_path}"
+        command += f" {target}"
+        return command
+
+    def _calculate_score(self, ret: int, lines: List[str], verbose: bool = False) -> float:
+        from ...enforcers import exit_if
+        if len(lines) == 1 and lines[0].endswith("No module named pylint"):
+            raise RuntimeError(f"No module named pylint found")
+        rating_line = lines[-2]
+        m = self.RATING_PATTERN.match(rating_line)
+        msg = f"Failed running Pylint, got exit code {ret}. Try running manually using:\n\t{self._build_command('TARGET')}"
+        exit_if(not m, msg)
+        rating_string = m.group(1)  # type:ignore
+        numerator, denominator = rating_string.split("/")
+        return float(numerator) / float(denominator)
+
+
+__all__ = [
+    "PylintRunner",
+]

quickpub-1.0.0/quickpub/runnables/implementations/pytest.py

@@ -0,0 +1,2 @@
+from ..base_runner import BaseRunner
+# TODO

{quickpub-0.8.3 → quickpub-1.0.0}/quickpub/runnables/implementations/unittest.py

@@ -1,13 +1,20 @@
 import re
 import os
 from typing import Optional, List
-from danielutils import get_current_working_directory, set_current_working_directory
-from ..common_check import CommonCheck
+from danielutils import get_current_working_directory, set_current_working_directory, LayeredCommand, warning
 
+from ..base_runner import BaseRunner
+
+
+class UnittestRunner(BaseRunner):
+    def _install_dependencies(self, base: LayeredCommand) -> None:
+        return None
 
-class UnittestRunner(CommonCheck):
     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 _post_command(self):
@@ -16,16 +23,16 @@ class UnittestRunner(CommonCheck):
     RATING_PATTERN: re.Pattern = re.compile(r".*?([\d\.\/]+)")
 
     def __init__(self, target: Optional[str] = "./tests", bound: str = ">=0.8") -> None:
-        CommonCheck.__init__(self, "unittest", bound, target)
+        BaseRunner.__init__(self, name="unittest", bound=bound, target=target)
         self._cwd = ""
 
-    def _build_command(self, src: str, *args) -> str:
+    def _build_command(self, src: str, *args, use_system_interpreter: bool = False) -> str:
         command: str = self.get_executable()
         rel = os.path.relpath(src, self.target).removesuffix(src.lstrip("./\\"))
         command += f" discover -s {rel}"
         return command  # f"cd {self.target}; {command}"  # f"; cd {self.target}"
 
-    def _calculate_score(self, ret: int, lines: List[str]) -> float:
+    def _calculate_score(self, ret: int, lines: List[str], *, verbose: bool = False) -> float:
         from ...enforcers import exit_if
         num_tests_line = lines[-3]
         num_failed_line = lines[-1] if lines[-1] != "OK" else "0"

{quickpub-0.8.3 → quickpub-1.0.0}/quickpub/structures/additional_configuration.py

@@ -1,11 +1,13 @@
 from dataclasses import dataclass
 from typing import Optional, List
 from ..runnables import Runnable
+from ..managers import PythonManager
 
 
 @dataclass(frozen=True)
 class AdditionalConfiguration:
-    runners: Optional[List[Runnable]]
+    python_manager: Optional[PythonManager] = None
+    runners: Optional[List[Runnable]] = None
 
 
 __all__ = [

{quickpub-0.8.3 → quickpub-1.0.0}/quickpub/structures/bound.py

@@ -24,6 +24,12 @@ class Bound:
                 return Bound(op, float(splits[-1]))  # type:ignore
         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-0.8.3 → quickpub-1.0.0}/quickpub/structures/version.py

@@ -5,7 +5,11 @@ from dataclasses import dataclass
 class Version:
     @staticmethod
     def from_str(version_str: str) -> "Version":
-        return Version(*list(map(int, version_str.split("."))))
+        try:
+            return Version(*list(map(int, version_str.split("."))))
+        except Exception as e:
+            raise ValueError(f"Failed converting '{version_str}' to instance of 'Version' in 'Version.from_str") from e
+
 
     major: int = 0
     minor: int = 0

{quickpub-0.8.3 → quickpub-1.0.0}/quickpub/validators.py

@@ -1,16 +1,13 @@
 from typing import Optional, Union, List
 
 from danielutils import get_python_version
-from .custom_types import Path
 from .structures import Version
 
 
-def validate_version(version: Optional[Union[str, Version]]) -> Version:
+def validate_version(version: Optional[Union[str, Version]] = None) -> Version:
     if version is None:
-        version = Version(0, 0, 1)
-    else:
-        version: Version = version if isinstance(version, Version) else Version.from_str(version)  # type: ignore
-    return version
+        return Version(0, 0, 1)
+    return version if isinstance(version, Version) else Version.from_str(version)  # type: ignore
 
 
 def validate_python_version(min_python: Optional[Version]) -> Version:
@@ -31,7 +28,7 @@ def validate_dependencies(dependencies: Optional[List[str]]) -> List[str]:
     return dependencies
 
 
-def validate_source(name: str, src: Optional[Path] = None) -> Path:
+def validate_source(name: str, src: Optional[str] = None) -> str:
     if src is not None:
         return src
     return f"./{name}"

{quickpub-0.8.3 → quickpub-1.0.0/quickpub.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: quickpub
-Version: 0.8.3
+Version: 1.0.0
 Summary: A python package to quickly configure and publish a new package
 Author-email: danielnachumdev <danielnachumdev@gmail.com>
 License: MIT License

{quickpub-0.8.3 → quickpub-1.0.0}/quickpub.egg-info/SOURCES.txt

@@ -6,20 +6,25 @@ setup.py
 quickpub/__init__.py
 quickpub/__main__.py
 quickpub/classifiers.py
-quickpub/custom_types.py
 quickpub/enforcers.py
 quickpub/files.py
 quickpub/functions.py
 quickpub/proxy.py
 quickpub/py.typed
+quickpub/qa.py
 quickpub/validators.py
 quickpub.egg-info/PKG-INFO
 quickpub.egg-info/SOURCES.txt
 quickpub.egg-info/dependency_links.txt
 quickpub.egg-info/requires.txt
 quickpub.egg-info/top_level.txt
+quickpub/managers/__init__.py
+quickpub/managers/python_manager.py
+quickpub/managers/implementations/__init__.py
+quickpub/managers/implementations/conda.py
+quickpub/managers/implementations/system_interpreter.py
 quickpub/runnables/__init__.py
-quickpub/runnables/common_check.py
+quickpub/runnables/base_runner.py
 quickpub/runnables/configurable.py
 quickpub/runnables/has_optional_executable.py
 quickpub/runnables/runnable.py

quickpub-0.8.3/quickpub/custom_types.py

@@ -1,12 +0,0 @@
-from typing import TypeVar
-
-try:
-    from typing import TypeAlias
-except:
-    from typing_extensions import TypeAlias
-
-Path: TypeAlias = TypeVar("Path", bound=str)
-
-__all__ = [
-    "Path"
-]

quickpub-0.8.3/quickpub/runnables/common_check.py

@@ -1,53 +0,0 @@
-from abc import abstractmethod
-from typing import Optional, Union, List
-
-from danielutils import cm, info
-
-from .has_optional_executable import HasOptionalExecutable
-from .runnable import Runnable
-from .configurable import Configurable
-from ..structures import Bound
-
-
-class CommonCheck(Runnable, 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) -> None:
-        Configurable.__init__(self, configuration_path)
-        HasOptionalExecutable.__init__(self, name, executable_path)
-        self.bound: Bound = bound if isinstance(bound, Bound) else Bound.from_string(bound)
-        self.target = target
-
-    @abstractmethod
-    def _build_command(self, target: str) -> str:
-        ...
-
-    def _pre_command(self):
-        pass
-
-    def _post_command(self):
-        pass
-
-    def run(self, target: str, *_) -> None:
-        command = self._build_command(target)
-        info(f"Running {self.name}")
-        self._pre_command()
-        try:
-            ret, out, err = cm(command)
-            score = self._calculate_score(ret, b"".join([out, err]).decode("utf-8").splitlines())
-            from ..enforcers import exit_if
-            exit_if(not self.bound.compare_against(score), f"{self.name} failed to pass it's defined bound")
-        except Exception as e:
-            raise RuntimeError(f"Failed to run {self.name}, try running manually:\n{self._build_command('TARGET')}") from e
-        finally:
-            self._post_command()
-
-
-@abstractmethod
-def _calculate_score(self, ret: int, command_output: List[str]) -> float: ...
-
-
-__all__ = [
-    "CommonCheck"
-]

quickpub-0.8.3/quickpub/runnables/implementations/mypy.py

@@ -1,31 +0,0 @@
-import re
-from typing import Optional, List
-from ..common_check import CommonCheck
-
-
-class MypyRunner(CommonCheck):
-    def _build_command(self, target: str) -> str:
-        command: str = self.get_executable()
-        if self.has_config:
-            command += f" --config-file {self.config_path}"
-        command += f" {target}"
-        return command
-
-    RATING_PATTERN: re.Pattern = re.compile(r".*?([\d\.\/]+)")
-
-    def __init__(self, bound: str = "<15", configuration_path: Optional[str] = None,
-                 executable_path: Optional[str] = None) -> None:
-        CommonCheck.__init__(self, "mypy", bound, configuration_path, executable_path)
-
-    def _calculate_score(self, ret, lines: List[str]) -> float:
-        from ...enforcers import exit_if
-        rating_line = lines[-1]
-        exit_if(not (m := self.RATING_PATTERN.match(rating_line)),
-                f"Failed running MyPy, got exit code {ret}. try running manually using:\n\t{self._build_command('TARGE')}")
-        rating_string = m.group(1)
-        return float(rating_string)
-
-
-__all__ = [
-    'MypyRunner',
-]

quickpub-0.8.3/quickpub/runnables/implementations/pylint.py

@@ -1,30 +0,0 @@
-import re
-from typing import Optional, List
-from ..common_check import CommonCheck
-
-
-class PylintRunner(CommonCheck):
-    RATING_PATTERN: re.Pattern = re.compile(r".*?([\d\.\/]+)")
-    def __init__(self, bound: str = ">=0.8", configuration_path: Optional[str] = None,
-                 executable_path: Optional[str] = None) -> None:
-        CommonCheck.__init__(self, "pylint", bound, configuration_path, executable_path)
-
-    def _build_command(self, target: str) -> str:
-        command: str = self.get_executable()
-        if self.has_config:
-            command += f" --rcfile {self.config_path}"
-        command += f" {target}"
-        return command
-    def _calculate_score(self, ret: int, lines: List[str]) -> float:
-        from ...enforcers import exit_if
-        rating_line = lines[-2]
-        exit_if(not (m := self.RATING_PATTERN.match(rating_line)),
-                f"Failed running Pylint, got exit code {ret}. try running manually using:\n\t{self._build_command('TARGET')}")
-        rating_string = m.group(1)  # type:ignore
-        numerator, denominator = rating_string.split("/")
-        return float(numerator) / float(denominator)
-
-
-__all__ = [
-    "PylintRunner",
-]

quickpub-0.8.3/quickpub/runnables/implementations/pytest.py

@@ -1 +0,0 @@
-# TODO