quickpub 1.0.3__tar.gz → 2.0.1__tar.gz

{quickpub-1.0.3/quickpub.egg-info → quickpub-2.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: quickpub
-Version: 1.0.3
+Version: 2.0.1
 Summary: A python package to quickly configure and publish a new package
 Author-email: danielnachumdev <danielnachumdev@gmail.com>
 License: MIT License
@@ -38,9 +38,11 @@ License-File: LICENSE
 **Tested python versions**: `3.8.0`, `3.9.0`, `3.10.13`,
 
 Example usage of how this package was published
+
 ```python
-from quickpub import publish, MypyRunner, PylintRunner, UnittestRunner, CondaPythonProvider, \
-    PypircUploadTarget, SetuptoolsBuildSchema, GithubUploadTarget
+from quickpub import publish, MypyRunner, PylintRunner, UnittestRunner, CondaPythonProvider,
+    PypircUploadTarget, SetuptoolsBuildSchema, GithubUploadTarget, PypircEnforcer, ReadmeEnforcer, LicenseEnforcer,
+    PypiRemoteVersionEnforcer, LocalVersionEnforcer
 
 
 def main() -> None:
@@ -51,21 +53,24 @@ def main() -> None:
         author_email="danielnachumdev@gmail.com",
         description="A python package to quickly configure and publish a new package",
         homepage="https://github.com/danielnachumdev/quickpub",
+        enforcers=[
+            PypircEnforcer(), ReadmeEnforcer(), LicenseEnforcer(),
+            LocalVersionEnforcer(), PypiRemoteVersionEnforcer()
+        ],
         build_schemas=[SetuptoolsBuildSchema()],
         upload_targets=[PypircUploadTarget(), GithubUploadTarget()],
         python_interpreter_provider=CondaPythonProvider(["base", "390", "380"]),
-        quality_assurance_runners=[
+        global_quality_assurance_runners=[
             MypyRunner(bound="<=15", configuration_path="./mypy.ini"),
             PylintRunner(bound=">=0.8", configuration_path="./.pylintrc"),
             UnittestRunner(bound=">=0.8"),
         ],
-        dependencies=["danielutils>=0.9.90"],
+        dependencies=["danielutils>=0.9.92", "requests"],
         min_python="3.8.0",
+        demo=True
     )
 
 
 if __name__ == '__main__':
     main()
-
-
 ```

{quickpub-1.0.3 → quickpub-2.0.1}/README.md

@@ -2,9 +2,11 @@
 **Tested python versions**: `3.8.0`, `3.9.0`, `3.10.13`,
 
 Example usage of how this package was published
+
 ```python
-from quickpub import publish, MypyRunner, PylintRunner, UnittestRunner, CondaPythonProvider, \
-    PypircUploadTarget, SetuptoolsBuildSchema, GithubUploadTarget
+from quickpub import publish, MypyRunner, PylintRunner, UnittestRunner, CondaPythonProvider,
+    PypircUploadTarget, SetuptoolsBuildSchema, GithubUploadTarget, PypircEnforcer, ReadmeEnforcer, LicenseEnforcer,
+    PypiRemoteVersionEnforcer, LocalVersionEnforcer
 
 
 def main() -> None:
@@ -15,21 +17,24 @@ def main() -> None:
         author_email="danielnachumdev@gmail.com",
         description="A python package to quickly configure and publish a new package",
         homepage="https://github.com/danielnachumdev/quickpub",
+        enforcers=[
+            PypircEnforcer(), ReadmeEnforcer(), LicenseEnforcer(),
+            LocalVersionEnforcer(), PypiRemoteVersionEnforcer()
+        ],
         build_schemas=[SetuptoolsBuildSchema()],
         upload_targets=[PypircUploadTarget(), GithubUploadTarget()],
         python_interpreter_provider=CondaPythonProvider(["base", "390", "380"]),
-        quality_assurance_runners=[
+        global_quality_assurance_runners=[
             MypyRunner(bound="<=15", configuration_path="./mypy.ini"),
             PylintRunner(bound=">=0.8", configuration_path="./.pylintrc"),
             UnittestRunner(bound=">=0.8"),
         ],
-        dependencies=["danielutils>=0.9.90"],
+        dependencies=["danielutils>=0.9.92", "requests"],
         min_python="3.8.0",
+        demo=True
     )
 
 
 if __name__ == '__main__':
     main()
-
-
 ```

{quickpub-1.0.3 → quickpub-2.0.1}/pyproject.toml

@@ -4,11 +4,11 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "quickpub"
-version = "1.0.3"
+version = "2.0.1"
 authors = [
     { name = "danielnachumdev", email = "danielnachumdev@gmail.com" },
 ]
-dependencies = ['danielutils>=0.9.90']
+dependencies = ['danielutils>=0.9.94', 'requests']
 keywords = []
 license = { "file" = "./LICENSE" }
 description = "A python package to quickly configure and publish a new package"

{quickpub-1.0.3 → quickpub-2.0.1}/quickpub/__main__.py

@@ -2,13 +2,13 @@ import argparse
 from typing import Optional, Union, List, Any
 from danielutils import warning, file_exists, error
 
-from .strategies import BuildSchema, UploadTarget, QualityAssuranceRunner, PythonProvider, DefaultInterpreterProvider
+from .strategies import BuildSchema, ConstraintEnforcer, UploadTarget, QualityAssuranceRunner, PythonProvider, \
+    DefaultPythonProvider
 from .validators import validate_version, validate_python_version, validate_keywords, validate_dependencies, \
     validate_source
 from .structures import Version, Dependency
 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 .qa import qa
 
 
@@ -22,8 +22,9 @@ def publish(
 
         build_schemas: List[BuildSchema],
         upload_targets: List[UploadTarget],
-        quality_assurance_runners: Optional[List[QualityAssuranceRunner]] = None,
-        python_interpreter_provider: PythonProvider = DefaultInterpreterProvider(),
+        enforcers: Optional[List[ConstraintEnforcer]] = None,
+        global_quality_assurance_runners: Optional[List[QualityAssuranceRunner]] = None,
+        python_interpreter_provider: PythonProvider = DefaultPythonProvider(),
 
         readme_file_path: str = "./README.md",
         license_file_path: str = "./LICENSE",
@@ -43,11 +44,11 @@ def publish(
      :param author_email: The email of the author.
      :param description: A short description of the package.
      :param homepage: The homepage URL for the package (e.g., GitHub repository).
-     :param quality_assurance_runners: Strategies for quality assurance.
+     :param global_quality_assurance_runners: Strategies for quality assurance. These will run on all Envs supplies by the supplier.
      :param build_schemas: Strategies for building the package.
      :param upload_targets: Strategies for uploading the package.
      :param python_interpreter_provider: Strategy for managing Python versions. Defaults to SystemInterpreter().
-     :param explicit_src_folder_path: The path to the source code of the package. Defaults to the current working directory/<name>.
+     :param explicit_src_folder_path: The path to the source code of the package. Defaults to <current working directory>/<name>.
      :param version: The version for the new distribution. Defaults to "0.0.1".
      :param readme_file_path: The path to the README file. Defaults to "./README.md".
      :param license_file_path: The path to the license file. Defaults to "./LICENSE".
@@ -60,28 +61,22 @@ def publish(
      Returns:
          None
      """
-
-    enforce_pypirc_exists()
+    version = validate_version(version)
     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_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)
-    if not demo:
-        enforce_local_correct_version(name, version)
     min_python = validate_python_version(min_python)  # type:ignore
     keywords = validate_keywords(keywords)
     validated_dependencies: List[Dependency] = validate_dependencies(dependencies)
-    enforce_remote_correct_version(name, version)
 
-    if quality_assurance_runners is None:
-        quality_assurance_runners = []
+    for enforcer in enforcers or []:
+        enforcer.enforce(name=name, version=version, demo=demo)
+
     try:
         res = qa(
             python_interpreter_provider,
-            quality_assurance_runners,
+            global_quality_assurance_runners or [],
             name,
             explicit_src_folder_path,
             validated_dependencies
@@ -119,10 +114,10 @@ def publish(
     )
     create_manifest(name=name)
     if not demo:
-        for build_strategy in build_schemas:
-            build_strategy.execute_strategy()
-        for upload_strategy in upload_targets:
-            upload_strategy.execute_strategy(name=name, version=version)
+        for schema in build_schemas:
+            schema.build()
+        for target in upload_targets:
+            target.upload(name=name, version=version)
 
 
 def parse_args():

{quickpub-1.0.3 → quickpub-2.0.1}/quickpub/classifiers.py

@@ -3,6 +3,10 @@ from enum import Enum
 
 
 class Classifier(Enum):
+    """
+    A base enum class for all classifiers.
+    """
+
     def _str(self) -> str:
         return str(self.value)
 
@@ -36,6 +40,9 @@ class Classifier(Enum):
 
 
 class DevelopmentStatusClassifier(Classifier):
+    """
+    An enum class for specifying the development state of the package
+    """
     # https://pypi.org/classifiers/
     Planning = 1
     PreAlpha = 2
@@ -51,15 +58,24 @@ class DevelopmentStatusClassifier(Classifier):
 
 
 class IntendedAudienceClassifier(Classifier):
+    """
+    An enum class for specifying the intended audience
+    """
     CustomerService = "CustomerService"
     Developers = "Developers"
 
 
 class ProgrammingLanguageClassifier(Classifier):
+    """
+    An enum class for specifying the target language level
+    """
     Python3 = "Python :: 3"
 
 
 class OperatingSystemClassifier(Classifier):
+    """
+    An enum class for specifying the target operating system
+    """
     MicrosoftWindows = "Microsoft :: Windows"
 
 

quickpub-2.0.1/quickpub/enforcers.py

@@ -0,0 +1,17 @@
+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-1.0.3 → quickpub-2.0.1}/quickpub/proxy.py

@@ -13,7 +13,7 @@ def os_system(command) -> int:
     return os.system(command)
 
 
-def get(*args, **kwargs):
+def get(*args, **kwargs) -> requests.models.Response:
     return requests.get(*args, **kwargs)
 
 

{quickpub-1.0.3 → quickpub-2.0.1}/quickpub/qa.py

@@ -42,7 +42,7 @@ def global_import_sanity_check(package_name: str, executor: LayeredCommand, is_s
     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 *"])
+        f.writelines([f"from {package_name} import *"])
         code, _, _ = executor(f"{p} {file_name}")
         exit_if(code != 0,
                 f"Env '{env_name}' failed sanity check. "
@@ -122,32 +122,25 @@ def create_pool_print_error(pool: ProgressBarPool):
 
 
 def qa(
-        python_version_manager: PythonProvider,
+        python_provider: PythonProvider,
         quality_assurance_strategies: List[QualityAssuranceRunner],
         package_name: str,
-        src_folder_path: Optional[str],
+        src_folder_path: str,
         dependencies: list
 ) -> bool:
-    from .strategies import DefaultInterpreterProvider
+    from .strategies import DefaultPythonProvider
     result = True
-    if python_version_manager is None:
-        python_version_manager = DefaultInterpreterProvider()
-    is_system_interpreter = isinstance(python_version_manager, DefaultInterpreterProvider)
-    pool = create_progress_bar_pool(python_version_manager, quality_assurance_strategies)
+    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 MultiContext(
-            AttrContext(LayeredCommand, 'class_flush_stdout', False),
-            AttrContext(LayeredCommand, 'class_flush_stderr', False),
-            AttrContext(LayeredCommand, 'class_raise_on_fail', False),
-            base := LayeredCommand()
-    ):
+    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_version_manager, dependencies, executor, env_name, pool_err)
+                    validate_dependencies(python_provider, dependencies, executor, env_name, pool_err)
                 except SystemExit:
                     result = False
                     continue
@@ -177,7 +170,7 @@ def qa(
                             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_version_manager.exit_on_fail:
+                        if python_provider.exit_on_fail:
                             raise RuntimeError() from e
     return result
 

{quickpub-1.0.3 → quickpub-2.0.1}/quickpub/strategies/__init__.py

@@ -4,3 +4,4 @@ from .quality_assurance_runner import *
 from .quickpub_strategy import *
 from .build_schema import *
 from .python_provider import *
+from .constraint_enforcer import *

{quickpub-1.0.3 → quickpub-2.0.1}/quickpub/strategies/build_schema.py

@@ -1,4 +1,5 @@
 from abc import abstractmethod
+from typing import Type
 
 from .quickpub_strategy import QuickpubStrategy
 
@@ -8,7 +9,7 @@ class BuildSchema(QuickpubStrategy):
         self.verbose = verbose
 
     @abstractmethod
-    def execute_strategy(self, *args, **kwargs) -> None: ...
+    def build(self, *args, **kwargs) -> None: ...
 
 
 __all__ = [

quickpub-2.0.1/quickpub/strategies/constraint_enforcer.py

@@ -0,0 +1,16 @@
+from abc import abstractmethod
+from typing import Type
+
+from .quickpub_strategy import QuickpubStrategy
+
+
+class ConstraintEnforcer(QuickpubStrategy):
+    EXCEPTION_TYPE: Type[BaseException] = SystemExit
+
+    @abstractmethod
+    def enforce(self, **kwargs) -> None: ...
+
+
+__all__ = [
+    'ConstraintEnforcer'
+]

quickpub-2.0.1/quickpub/strategies/implementations/__init__.py

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

quickpub-2.0.1/quickpub/strategies/implementations/build_schemas/__init__.py

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

quickpub-2.0.1/quickpub/strategies/implementations/build_schemas/setuptools_build_schema.py

@@ -0,0 +1,26 @@
+from typing import Literal
+
+from danielutils import info, file_exists, LayeredCommand
+
+from ...build_schema import BuildSchema
+
+
+class SetuptoolsBuildSchema(BuildSchema):
+    def __init__(self, setup_file_path: str = "./setup.py", backend: Literal["toml"] = "toml") -> None:
+        self._backend = backend
+        self._setup_file_path = setup_file_path
+
+    def build(self, verbose: bool = False, *args, **kwargs) -> None:
+        if not file_exists(self._setup_file_path):
+            raise self.EXCEPTION_TYPE(f"Could not find {self._setup_file_path} file")
+        if verbose:
+            info("Creating new distribution...")
+        with LayeredCommand() as exc:
+            ret, stdout, stderr = exc("python " + self._setup_file_path + " sdist")
+        if ret != 0:
+            raise self.EXCEPTION_TYPE(stderr)
+
+
+__all__ = [
+    "SetuptoolsBuildSchema",
+]

quickpub-2.0.1/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-2.0.1/quickpub/strategies/implementations/constraint_enforcers/license_enforcer.py

@@ -0,0 +1,17 @@
+from danielutils import file_exists
+
+from ...constraint_enforcer import ConstraintEnforcer
+
+
+class LicenseEnforcer(ConstraintEnforcer):
+    def __init__(self, path: str = "./LICENSE") -> None:
+        self.path = path
+
+    def enforce(self, **kwargs) -> None:
+        if not file_exists(self.path):
+            raise self.EXCEPTION_TYPE(f"Could not find license file at '{self.path}'")
+
+
+__all__ = [
+    "LicenseEnforcer",
+]

quickpub-2.0.1/quickpub/strategies/implementations/constraint_enforcers/local_version_enforcer.py

@@ -0,0 +1,58 @@
+from danielutils import directory_exists, get_files, get_python_version
+
+from quickpub import Version
+from ...constraint_enforcer import ConstraintEnforcer
+
+
+def _remove_suffix(s: str, suffix: str) -> str:
+    """
+    This function is needed because str.removesuffix is not implemented in python == 3.8.0
+    :param s: string to remove from
+    :param suffix: substring to remove
+    :return: modified string
+    """
+    if get_python_version() >= (3, 9):
+        return s.removesuffix(suffix)  # type:ignore
+    return _remove_prefix(s[::-1], suffix[::-1])[::-1]
+
+
+def _remove_prefix(s: str, prefix: str) -> str:
+    """
+
+    :param s:
+    :param prefix:
+    :return:
+    """
+    if get_python_version() >= (3, 9):
+        return s.removeprefix(prefix)  # type:ignore
+
+    if s.startswith(prefix):
+        return s[len(prefix):]
+    return s
+
+
+class LocalVersionEnforcer(ConstraintEnforcer):
+    def enforce(self, name: str, version: Version, demo: bool = False, **kwargs) -> None:  # type: ignore
+        if demo:
+            return
+
+        if not directory_exists("./dist"):
+            return
+
+        prev_builds = get_files("./dist")
+        if len(prev_builds) == 0:
+            return
+
+        max_local_version = Version(0, 0, 0)
+        for d in prev_builds:
+            d = _remove_suffix(_remove_prefix(d, f"{name}-"), ".tar.gz")
+            v: Version = Version.from_str(d)
+            max_local_version = max(max_local_version, v)
+        if version <= max_local_version:
+            raise self.EXCEPTION_TYPE(
+                f"Specified version is '{version}' but (locally available) latest existing is '{max_local_version}'")
+
+
+__all__ = [
+    'LocalVersionEnforcer'
+]

quickpub-2.0.1/quickpub/strategies/implementations/constraint_enforcers/pypi_remote_version_enforcer.py

@@ -0,0 +1,39 @@
+from danielutils import RetryExecutor, ExponentialBackOffStrategy, ConstantBackOffStrategy
+from requests import Response
+
+from proxy import get  # type: ignore
+from quickpub import Version
+from ...constraint_enforcer import ConstraintEnforcer
+
+
+class PypiRemoteVersionEnforcer(ConstraintEnforcer):
+    _HTTP_FAILED_MESSAGE: str = "Failed to send http request"
+
+    def enforce(self, name: str, version: Version, demo: bool = False, **kwargs) -> None:  # type: ignore
+        if demo:
+            return
+        url = f"https://pypi.org/project/{name}/"
+
+        timeout_strategy = ExponentialBackOffStrategy(1.1, 1.5)
+
+        def wrapper() -> Response:
+            return get(url, timeout=timeout_strategy.get_backoff())
+
+        executor: RetryExecutor[Response] = RetryExecutor(ConstantBackOffStrategy(1))
+        response = executor.execute(wrapper, 5)
+        if response is None:
+            raise SystemExit(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
+        if not version > remote_version:
+            raise SystemExit(
+                f"Specified version is '{version}' but (remotely available) latest existing is '{remote_version}'")
+
+
+__all__ = [
+    'PypiRemoteVersionEnforcer'
+]

quickpub-2.0.1/quickpub/strategies/implementations/constraint_enforcers/pypirc_enforcer.py

@@ -0,0 +1,29 @@
+import re
+
+from danielutils import file_exists
+
+from ...constraint_enforcer import ConstraintEnforcer
+
+
+class PypircEnforcer(ConstraintEnforcer):
+    PYPIRC_REGEX: re.Pattern = re.compile(
+        r"\[distutils\]\nindex-servers =\n\s*pypi\n\s*testpypi\n\n\[pypi\]\n\s*username = __token__\n\s*password = .+\n\n\[testpypi\]\n\s*username = __token__\n\s*password = .+\n?")  # pylint: disable=line-too-long
+
+    def __init__(self, path: str = "./.pypirc", should_enforce_expected_format: bool = True) -> None:
+        self.path = path
+        self.should_enforce_expected_format = should_enforce_expected_format
+
+    def enforce(self, **kwargs) -> None:
+        if not file_exists(self.path):
+            raise SystemExit(f"Couldn't find '{self.path}'")
+        if self.should_enforce_expected_format:
+            with open(self.path, "r") as f:
+                text = f.read()
+
+            if not self.PYPIRC_REGEX.match(text):
+                raise self.EXCEPTION_TYPE(f"Couldn't enforce '{self.path}'")
+
+
+__all__ = [
+    "PypircEnforcer",
+]

quickpub-2.0.1/quickpub/strategies/implementations/constraint_enforcers/readme_enforcer.py

@@ -0,0 +1,20 @@
+from typing import Type
+
+from danielutils import file_exists
+
+from ...constraint_enforcer import ConstraintEnforcer
+
+
+class ReadmeEnforcer(ConstraintEnforcer):
+
+    def __init__(self, path: str = "./README.md") -> None:
+        self.path = path
+
+    def enforce(self, **kwargs) -> None:
+        if not file_exists(self.path):
+            raise self.EXCEPTION_TYPE(f"Could not find readme file at '{self.path}'")
+
+
+__all__ = [
+    "ReadmeEnforcer",
+]

quickpub-2.0.1/quickpub/strategies/implementations/python_providers/__init__.py

@@ -0,0 +1,2 @@
+from .conda_python_provider import *
+from .default_python_provider import *

quickpub-1.0.3/quickpub/strategies/implementations/conda_python_version_manager_strategy.py → quickpub-2.0.1/quickpub/strategies/implementations/python_providers/conda_python_provider.py

@@ -1,7 +1,7 @@
 from typing import Tuple, Optional, Set, Iterator, List
 from danielutils import LayeredCommand, warning
 
-from ..python_provider import PythonProvider
+from ...python_provider import PythonProvider
 
 
 class CondaPythonProvider(PythonProvider):
@@ -12,16 +12,11 @@ class CondaPythonProvider(PythonProvider):
         PythonProvider.__init__(self, requested_envs=env_names, explicit_versions=[], exit_on_fail=True)
         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:
+    @classmethod
+    def _get_available_envs_impl(cls) -> Set[str]:
+        with LayeredCommand() 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
+        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()

quickpub-1.0.3/quickpub/strategies/implementations/system_interpreter.py → quickpub-2.0.1/quickpub/strategies/implementations/python_providers/default_python_provider.py

@@ -3,10 +3,10 @@ from typing import Set, Tuple, Iterator
 
 from danielutils import LayeredCommand
 
-from ..python_provider import PythonProvider
+from ...python_provider import PythonProvider
 
 
-class DefaultInterpreterProvider(PythonProvider):
+class DefaultPythonProvider(PythonProvider):
     def get_python_executable_name(self) -> str:
         return sys.executable
 
@@ -14,12 +14,13 @@ class DefaultInterpreterProvider(PythonProvider):
         PythonProvider.__init__(self, requested_envs=["system"], explicit_versions=[], exit_on_fail=True)
 
     def __iter__(self) -> Iterator[Tuple[str, LayeredCommand]]:
-        return iter([("system", LayeredCommand(""))])
+        return iter([("system", LayeredCommand("", instance_flush_stderr=False, instance_flush_stdout=False))])
 
-    def get_available_envs(self) -> Set[str]:
+    @classmethod
+    def _get_available_envs_impl(cls) -> Set[str]:
         return set("system")
 
 
 __all__ = [
-    "DefaultInterpreterProvider",
+    "DefaultPythonProvider",
 ]

quickpub-2.0.1/quickpub/strategies/implementations/quality_assurance_runners/__init__.py

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