quickpub 1.0.2__tar.gz → 1.0.3__tar.gz

{quickpub-1.0.2 → quickpub-1.0.3}/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2022 danielnachumdev
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+MIT License
+
+Copyright (c) 2022 danielnachumdev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: quickpub
-Version: 1.0.2
+Version: 1.0.3
 Summary: A python package to quickly configure and publish a new package
 Author-email: danielnachumdev <danielnachumdev@gmail.com>
 License: MIT License
@@ -34,35 +34,38 @@ Requires-Python: >=3.8.0
 Description-Content-Type: text/markdown
 License-File: LICENSE
 
-# quickpub V0.8.3
+# quickpub V1.0.3
 **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, AdditionalConfiguration, MypyRunner, PylintRunner, UnittestRunner
+from quickpub import publish, MypyRunner, PylintRunner, UnittestRunner, CondaPythonProvider, \
+    PypircUploadTarget, SetuptoolsBuildSchema, GithubUploadTarget
 
 
 def main() -> None:
     publish(
         name="quickpub",
-        version="0.8.0",
+        version="1.0.3",
         author="danielnachumdev",
         author_email="danielnachumdev@gmail.com",
         description="A python package to quickly configure and publish a new package",
         homepage="https://github.com/danielnachumdev/quickpub",
-        dependencies=["twine", "danielutils"],
-        min_python="3.9.19",
-        config=AdditionalConfiguration(
-            runners=[
-                MypyRunner(bound="<15"),
-                PylintRunner(bound=">=0.8"),
-                UnittestRunner(bound=">=0.8"),
-            ]
-        )
+        build_schemas=[SetuptoolsBuildSchema()],
+        upload_targets=[PypircUploadTarget(), GithubUploadTarget()],
+        python_interpreter_provider=CondaPythonProvider(["base", "390", "380"]),
+        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"],
+        min_python="3.8.0",
     )
 
 
 if __name__ == '__main__':
     main()
 
+
 ```

quickpub-1.0.3/README.md

@@ -0,0 +1,35 @@
+# quickpub V1.0.3
+**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
+
+
+def main() -> None:
+    publish(
+        name="quickpub",
+        version="1.0.3",
+        author="danielnachumdev",
+        author_email="danielnachumdev@gmail.com",
+        description="A python package to quickly configure and publish a new package",
+        homepage="https://github.com/danielnachumdev/quickpub",
+        build_schemas=[SetuptoolsBuildSchema()],
+        upload_targets=[PypircUploadTarget(), GithubUploadTarget()],
+        python_interpreter_provider=CondaPythonProvider(["base", "390", "380"]),
+        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"],
+        min_python="3.8.0",
+    )
+
+
+if __name__ == '__main__':
+    main()
+
+
+```

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

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

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

@@ -2,8 +2,7 @@ import argparse
 from typing import Optional, Union, List, Any
 from danielutils import warning, file_exists, error
 
-from quickpub import SystemInterpreter
-from strategies import BuildStrategy, UploadStrategy, QualityAssuranceStrategy, PythonVersionManagerStrategy
+from .strategies import BuildSchema, UploadTarget, QualityAssuranceRunner, PythonProvider, DefaultInterpreterProvider
 from .validators import validate_version, validate_python_version, validate_keywords, validate_dependencies, \
     validate_source
 from .structures import Version, Dependency
@@ -21,22 +20,20 @@ def publish(
         description: str,
         homepage: str,
 
-        build_strategies: List[BuildStrategy],
-        upload_strategies: List[UploadStrategy],
-        quality_assurance_strategies: Optional[List[QualityAssuranceStrategy]] = None,
-        python_version_manager_strategy: PythonVersionManagerStrategy = SystemInterpreter(),
+        build_schemas: List[BuildSchema],
+        upload_targets: List[UploadTarget],
+        quality_assurance_runners: Optional[List[QualityAssuranceRunner]] = None,
+        python_interpreter_provider: PythonProvider = DefaultInterpreterProvider(),
 
-        explicit_src_folder_path: Optional[str] = None,
-        version: Optional[Union[Version, str]] = None,
         readme_file_path: str = "./README.md",
         license_file_path: str = "./LICENSE",
-
+        version: Optional[Union[Version, str]] = None,
         min_python: Optional[Union[Version, str]] = None,
-
-        keywords: Optional[List[str]] = None,
         dependencies: Optional[List[Union[str, Dependency]]] = None,
-        demo: bool = False,
+        keywords: Optional[List[str]] = None,
+        explicit_src_folder_path: Optional[str] = None,
 
+        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.
@@ -46,10 +43,10 @@ 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_strategies: Strategies for quality assurance.
-     :param build_strategies: Strategies for building the package.
-     :param upload_strategies: Strategies for uploading the package.
-     :param python_version_manager_strategy: Strategy for managing Python versions. Defaults to SystemInterpreter().
+     :param quality_assurance_runners: Strategies for quality assurance.
+     :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 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".
@@ -79,12 +76,12 @@ def publish(
     validated_dependencies: List[Dependency] = validate_dependencies(dependencies)
     enforce_remote_correct_version(name, version)
 
-    if quality_assurance_strategies is None:
-        quality_assurance_strategies = []
+    if quality_assurance_runners is None:
+        quality_assurance_runners = []
     try:
         res = qa(
-            python_version_manager_strategy,
-            quality_assurance_strategies,
+            python_interpreter_provider,
+            quality_assurance_runners,
             name,
             explicit_src_folder_path,
             validated_dependencies
@@ -122,9 +119,9 @@ def publish(
     )
     create_manifest(name=name)
     if not demo:
-        for build_strategy in build_strategies:
+        for build_strategy in build_schemas:
             build_strategy.execute_strategy()
-        for upload_strategy in upload_strategies:
+        for upload_strategy in upload_targets:
             upload_strategy.execute_strategy(name=name, version=version)
 
 

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

@@ -4,8 +4,7 @@ from functools import wraps
 from typing import Optional, ContextManager, List, Callable, Tuple, Dict, Union
 from danielutils import AttrContext, LayeredCommand, AsciiProgressBar, ColoredText, ProgressBarPool, TemporaryFile
 
-from quickpub import QualityAssuranceStrategy
-from .strategies import PythonVersionManagerStrategy  # pylint: disable=relative-beyond-top-level
+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
 
@@ -54,7 +53,7 @@ def global_import_sanity_check(package_name: str, executor: LayeredCommand, is_s
 VERSION_REGEX: re.Pattern = re.compile(r"^\d+\.\d+\.\d+$")
 
 
-def validate_dependencies(python_manager: PythonVersionManagerStrategy, required_dependencies: List[Dependency],
+def validate_dependencies(python_manager: PythonProvider, required_dependencies: List[Dependency],
                           executor: LayeredCommand,
                           env_name: str, err_print_func: Callable) -> None:
     """
@@ -86,15 +85,15 @@ def validate_dependencies(python_manager: PythonVersionManagerStrategy, required
                         (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, "rInvalid version installed"))
+                        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: PythonVersionManagerStrategy,
-                             quality_assurance_strategies: List[QualityAssuranceStrategy]) -> ProgressBarPool:
+def create_progress_bar_pool(python_version_manager: PythonProvider,
+                             quality_assurance_strategies: List[QualityAssuranceRunner]) -> ProgressBarPool:
     return ProgressBarPool(
         AsciiProgressBar,
         2,
@@ -123,17 +122,17 @@ def create_pool_print_error(pool: ProgressBarPool):
 
 
 def qa(
-        python_version_manager: PythonVersionManagerStrategy,
-        quality_assurance_strategies: List[QualityAssuranceStrategy],
+        python_version_manager: PythonProvider,
+        quality_assurance_strategies: List[QualityAssuranceRunner],
         package_name: str,
         src_folder_path: Optional[str],
         dependencies: list
 ) -> bool:
-    from .strategies import SystemInterpreter
+    from .strategies import DefaultInterpreterProvider
     result = True
     if python_version_manager is None:
-        python_version_manager = SystemInterpreter()
-    is_system_interpreter = isinstance(python_version_manager, SystemInterpreter)
+        python_version_manager = DefaultInterpreterProvider()
+    is_system_interpreter = isinstance(python_version_manager, DefaultInterpreterProvider)
     pool = create_progress_bar_pool(python_version_manager, quality_assurance_strategies)
     pool_err = create_pool_print_error(pool)
     with MultiContext(
@@ -165,7 +164,6 @@ def qa(
                             src_folder_path,
                             executor,
                             use_system_interpreter=is_system_interpreter,
-                            raise_on_fail=python_version_manager.exit_on_fail,
                             print_func=pool_err,
                             env_name=env_name
                         )

quickpub-1.0.3/quickpub/strategies/__init__.py

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

quickpub-1.0.2/quickpub/strategies/build_strategy.py → quickpub-1.0.3/quickpub/strategies/build_schema.py

@@ -3,7 +3,7 @@ from abc import abstractmethod
 from .quickpub_strategy import QuickpubStrategy
 
 
-class BuildStrategy(QuickpubStrategy):
+class BuildSchema(QuickpubStrategy):
     def __init__(self, verbose: bool = True) -> None:
         self.verbose = verbose
 
@@ -12,5 +12,5 @@ class BuildStrategy(QuickpubStrategy):
 
 
 __all__ = [
-    "BuildStrategy"
+    "BuildSchema"
 ]

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

@@ -0,0 +1,9 @@
+from .pypirc_upload_target import *
+from .github_upload_target import *
+from .setuptools_build_schema import *
+from .mypy_qa_runner import *
+from .pylint_qa_runner import *
+from .pytest_qa_runner import *
+from .unittest_qa_runner import *
+from .conda_python_version_manager_strategy import *
+from .system_interpreter import *

{quickpub-1.0.2 → quickpub-1.0.3}/quickpub/strategies/implementations/conda_python_version_manager_strategy.py

@@ -1,15 +1,15 @@
 from typing import Tuple, Optional, Set, Iterator, List
 from danielutils import LayeredCommand, warning
 
-from ..python_version_manager_strategy import PythonVersionManagerStrategy
+from ..python_provider import PythonProvider
 
 
-class CondaPythonVersionManagerStrategy(PythonVersionManagerStrategy):
+class CondaPythonProvider(PythonProvider):
     def get_python_executable_name(self) -> str:
         return "python"
 
     def __init__(self, env_names: List[str]) -> None:
-        PythonVersionManagerStrategy.__init__(self, requested_envs=env_names, explicit_versions=[], exit_on_fail=True)
+        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]:
@@ -33,5 +33,5 @@ class CondaPythonVersionManagerStrategy(PythonVersionManagerStrategy):
 
 
 __all__ = [
-    'CondaPythonVersionManagerStrategy',
+    'CondaPythonProvider',
 ]

quickpub-1.0.2/quickpub/strategies/implementations/git_upload_strategy.py → quickpub-1.0.3/quickpub/strategies/implementations/github_upload_target.py

@@ -1,8 +1,8 @@
 from danielutils import info
 
-from ..upload_strategy import UploadStrategy
+from ..upload_target import UploadTarget
 
-class GitUploadStrategy(UploadStrategy):
+class GithubUploadTarget(UploadTarget):
     def execute_strategy(self, version: str, **kwargs) -> None:
         from quickpub.proxy import cm
         from quickpub.enforcers import exit_if
@@ -22,5 +22,5 @@ class GitUploadStrategy(UploadStrategy):
 
 
 __all__ = [
-    "GitUploadStrategy",
+    "GithubUploadTarget",
 ]

quickpub-1.0.2/quickpub/strategies/implementations/mypy_qa_strategy.py → quickpub-1.0.3/quickpub/strategies/implementations/mypy_qa_runner.py

@@ -3,10 +3,10 @@ from typing import Optional, List
 
 from danielutils import LayeredCommand
 
-from ..quality_assurance_strategy import QualityAssuranceStrategy
+from ..quality_assurance_runner import QualityAssuranceRunner
 
 
-class MypyRunner(QualityAssuranceStrategy):
+class MypyRunner(QualityAssuranceRunner):
     def _install_dependencies(self, base: LayeredCommand) -> None:
         with base:
             base("pip install pylint")
@@ -23,8 +23,8 @@ class MypyRunner(QualityAssuranceStrategy):
 
     def __init__(self, bound: str = "<15", configuration_path: Optional[str] = None,
                  executable_path: Optional[str] = None) -> None:
-        QualityAssuranceStrategy.__init__(self, name="mypy", bound=bound, configuration_path=configuration_path,
-                                          executable_path=executable_path)
+        QualityAssuranceRunner.__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

quickpub-1.0.2/quickpub/strategies/implementations/pylint_qa_strategy.py → quickpub-1.0.3/quickpub/strategies/implementations/pylint_qa_runner.py

@@ -3,10 +3,10 @@ from typing import Optional, List
 
 from danielutils import LayeredCommand
 
-from strategies.quality_assurance_strategy import QualityAssuranceStrategy
+from ..quality_assurance_runner import QualityAssuranceRunner
 
 
-class PylintRunner(QualityAssuranceStrategy):
+class PylintRunner(QualityAssuranceRunner):
     def _install_dependencies(self, base: LayeredCommand) -> None:
         with base:
             base("pip install pylint")
@@ -15,8 +15,8 @@ class PylintRunner(QualityAssuranceStrategy):
 
     def __init__(self, bound: str = ">=0.8", configuration_path: Optional[str] = None,
                  executable_path: Optional[str] = None) -> None:
-        QualityAssuranceStrategy.__init__(self, name="pylint", bound=bound, configuration_path=configuration_path,
-                                          executable_path=executable_path)
+        QualityAssuranceRunner.__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()

quickpub-1.0.2/quickpub/strategies/implementations/pypirc_upload_strategy.py → quickpub-1.0.3/quickpub/strategies/implementations/pypirc_upload_target.py

@@ -2,12 +2,12 @@ import re
 
 from danielutils import file_exists, info
 
-from ..upload_strategy import UploadStrategy
+from ..upload_target import UploadTarget
 
 
-class PypircUploadStrategy(UploadStrategy):
+class PypircUploadTarget(UploadTarget):
     REGEX_PATTERN: re.Pattern = re.compile(
-        r"\[distutils\]\nindex-servers =\n    pypi\n    testpypi\n\n\[pypi\]\nusername = __token__\npassword = .+\n\n\[testpypi\]\nusername = __token__\npassword = .+\n")
+        r"\[distutils\]\nindex-servers =\n    pypi\n    testpypi\n\n\[pypi\]\n    username = __token__\n    password = .+\n\n\[testpypi\]\n    username = __token__\n    password = .+\n?")
 
     def execute_strategy(self, *, name: str, version: str, **kwargs) -> None:
         from quickpub.proxy import cm
@@ -32,7 +32,7 @@ class PypircUploadStrategy(UploadStrategy):
             text = f.read()
         if not self.REGEX_PATTERN.match(text):
             raise RuntimeError(
-                f"{self.__class__.__name__} checked the contents of '{self.pypirc_file_path}' and it failed to match the following regex: {self.REGEX_PATTERN.pattern}")
+                f"{self.__class__.__name__} checked the contents of '{self.pypirc_file_path}' and it failed to match the following regex: r\"{self.REGEX_PATTERN.pattern}\"")
 
     def __init__(self, pypirc_file_path: str = "./.pypirc", verbose: bool = False) -> None:
         super().__init__(verbose)
@@ -40,5 +40,5 @@ class PypircUploadStrategy(UploadStrategy):
 
 
 __all__ = [
-    "PypircUploadStrategy"
+    "PypircUploadTarget"
 ]

quickpub-1.0.3/quickpub/strategies/implementations/pytest_qa_runner.py

@@ -0,0 +1,95 @@
+import re
+from typing import List, Union, Optional
+
+from danielutils import LayeredCommand
+
+from quickpub import Bound
+from ..quality_assurance_runner import QualityAssuranceRunner
+
+
+class PytestRunner(QualityAssuranceRunner):
+    """
+    PytestRunner is a concrete implementation of QualityAssuranceRunner specifically for running
+    pytest-based tests. It includes methods to build the pytest command, install pytest dependencies,
+    and calculate the test score based on pytest results.
+
+    Attributes:
+        PYTEST_REGEX (re.Pattern): A regex pattern to parse pytest results for passed and failed tests.
+    """
+
+    PYTEST_REGEX: re.Pattern = re.compile(
+        r"=+ (?:(?P<failed>\d+) failed,? )?(?:(?P<passed>\d+) passed )?in [\d\.]+s =+")
+
+    def __init__(
+            self, *,
+            bound: Union[str, Bound] = ">=0.8",
+            target: str = "./tests",
+            no_output_score: float = 0.0,
+            no_tests_score: float = 1.0
+    ):
+        """
+        Initializes the PytestRunner with a bound and target directory for tests.
+
+        :param bound: The bound representing acceptable limits, either as a string or a Bound object.
+                      Default is ">=0.8".
+        :param target: The target directory containing the tests. Default is "./tests".
+        """
+        super().__init__(
+            name="pytest",
+            bound=bound,
+            target=target
+        )
+        if not (0.0 <= no_tests_score <= 1.0):
+            raise RuntimeError("no_tests_score should be between 0.0 and 1.0 (including both).")
+        self.no_tests_score = no_tests_score
+
+        if not (0.0 <= no_output_score <= 1.0):
+            raise RuntimeError("no_output_score should be between 0.0 and 1.0 (including both).")
+        self.no_output_score = no_output_score
+
+    def _build_command(self, target: str, use_system_interpreter: bool = False) -> str:
+        """
+        Builds the command to run pytest on the specified target.
+
+        :param target: The target directory containing the tests.
+        :param use_system_interpreter: Whether to use the system interpreter. Default is False.
+        :return: The command to run pytest as a string.
+        """
+        if self.has_config:
+            return "pytest"
+        return f"pytest {self.target}"
+
+    def _install_dependencies(self, base: LayeredCommand) -> None:
+        """
+        Installs pytest and its dependencies.
+
+        :param base: The base LayeredCommand object for executing commands.
+        """
+        with base:
+            base("pip install pytest")
+
+    def _calculate_score(self, ret: int, command_output: List[str], *, verbose: bool = False) -> float:
+        """
+        Calculates the test score based on the pytest command output.
+
+        :param ret: The return code of the pytest command.
+        :param command_output: The output of the pytest command as a list of strings.
+        :param verbose: Whether to output verbose logs. Default is False.
+        :return: The calculated test score as a float.
+        """
+        if len(command_output) == 0:
+            return self.no_output_score
+        rating_line = command_output[-1]
+        if "no tests ran" in rating_line:
+            return self.no_tests_score
+        if not (m := self.PYTEST_REGEX.match(rating_line)):
+            raise SystemExit(1)
+
+        dct = m.groupdict()
+        failed = int(dct["failed"] or "0")
+        passed = int(dct["passed"] or "0")
+        assert failed >= 0
+        assert passed >= 0
+        if failed + passed == 0:
+            return self.no_tests_score
+        return passed / (passed + failed)

quickpub-1.0.2/quickpub/strategies/implementations/setuptools_build_strategy.py → quickpub-1.0.3/quickpub/strategies/implementations/setuptools_build_schema.py

@@ -1,9 +1,9 @@
 from danielutils import info
 
-from ..build_strategy import BuildStrategy
+from ..build_schema import BuildSchema
 
 
-class SetuptoolsBuildStrategy(BuildStrategy):
+class SetuptoolsBuildSchema(BuildSchema):
     def execute_strategy(self, *args, **kwargs) -> None:
         from quickpub.proxy import cm
         from quickpub.enforcers import exit_if
@@ -17,5 +17,5 @@ class SetuptoolsBuildStrategy(BuildStrategy):
 
 
 __all__ = [
-    "SetuptoolsBuildStrategy",
+    "SetuptoolsBuildSchema",
 ]

{quickpub-1.0.2 → quickpub-1.0.3}/quickpub/strategies/implementations/system_interpreter.py

@@ -3,15 +3,15 @@ from typing import Set, Tuple, Iterator
 
 from danielutils import LayeredCommand
 
-from ..python_version_manager_strategy import PythonVersionManagerStrategy
+from ..python_provider import PythonProvider
 
 
-class SystemInterpreter(PythonVersionManagerStrategy):
+class DefaultInterpreterProvider(PythonProvider):
     def get_python_executable_name(self) -> str:
         return sys.executable
 
     def __init__(self) -> None:
-        PythonVersionManagerStrategy.__init__(self, requested_envs=["system"], explicit_versions=[], exit_on_fail=True)
+        PythonProvider.__init__(self, requested_envs=["system"], explicit_versions=[], exit_on_fail=True)
 
     def __iter__(self) -> Iterator[Tuple[str, LayeredCommand]]:
         return iter([("system", LayeredCommand(""))])
@@ -21,5 +21,5 @@ class SystemInterpreter(PythonVersionManagerStrategy):
 
 
 __all__ = [
-    "SystemInterpreter",
+    "DefaultInterpreterProvider",
 ]

quickpub-1.0.2/quickpub/strategies/implementations/unittest_qa_strategy.py → quickpub-1.0.3/quickpub/strategies/implementations/unittest_qa_runner.py

@@ -3,10 +3,10 @@ import os
 from typing import Optional, List
 from danielutils import get_current_working_directory, set_current_working_directory, LayeredCommand, warning
 
-from strategies.quality_assurance_strategy import QualityAssuranceStrategy
+from ..quality_assurance_runner import QualityAssuranceRunner
 
 
-class UnittestRunner(QualityAssuranceStrategy):
+class UnittestRunner(QualityAssuranceRunner):
     def _install_dependencies(self, base: LayeredCommand) -> None:
         return None
 
@@ -23,7 +23,7 @@ class UnittestRunner(QualityAssuranceStrategy):
     RATING_PATTERN: re.Pattern = re.compile(r".*?([\d\.\/]+)")
 
     def __init__(self, target: Optional[str] = "./tests", bound: str = ">=0.8") -> None:
-        QualityAssuranceStrategy.__init__(self, name="unittest", bound=bound, target=target)
+        QualityAssuranceRunner.__init__(self, name="unittest", bound=bound, target=target)
         self._cwd = ""
 
     def _build_command(self, src: str, *args, use_system_interpreter: bool = False) -> str:
@@ -33,7 +33,6 @@ class UnittestRunner(QualityAssuranceStrategy):
         return command  # f"cd {self.target}; {command}"  # f"; cd {self.target}"
 
     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"
         try:
@@ -48,8 +47,8 @@ class UnittestRunner(QualityAssuranceStrategy):
 
             return 1.0 - (float(num_failed) / float(num_tests))
         except:
-            exit_if(True,
-                    f"Failed running Unittest, got exit code {ret}. try running manually using: {self._build_command('TARGET')}")
+            raise SystemExit(f"Failed running Unittest, got exit code {ret}. "
+                             f"try running manually using: {self._build_command('TARGET')}")
 
 
 __all__ = [

quickpub-1.0.2/quickpub/strategies/python_version_manager_strategy.py → quickpub-1.0.3/quickpub/strategies/python_provider.py

@@ -4,7 +4,7 @@ from typing import Tuple, Set, Iterator, List
 from danielutils import LayeredCommand
 
 
-class PythonVersionManagerStrategy(QuickpubStrategy):
+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:
@@ -27,5 +27,5 @@ class PythonVersionManagerStrategy(QuickpubStrategy):
 
 
 __all__ = [
-    'PythonVersionManagerStrategy'
+    'PythonProvider'
 ]

quickpub-1.0.3/quickpub/strategies/quality_assurance_runner.py

@@ -0,0 +1,167 @@
+import sys
+from abc import abstractmethod
+from typing import Union, List, Optional, cast
+from danielutils import LayeredCommand, get_os, OSType, file_exists
+
+from quickpub import Bound
+
+
+class Configurable:
+    @property
+    def has_config(self) -> bool:
+        return self.config_path is not None
+
+    def __init__(self, config_path: Optional[str] = None):
+        self.config_path = config_path
+        if self.has_config:
+            if not file_exists(self.config_path):
+                raise FileNotFoundError(f"Can't find config file {self.config_path}")
+
+
+class HasOptionalExecutable:
+    PYTHON: str = "python" if get_os() == OSType.WINDOWS else "python3"
+
+    @property
+    def use_executable(self) -> bool:
+        return self.executable_path is not None
+
+    def __init__(self, name, executable_path: Optional[str] = None) -> None:
+        self.name = name
+        self.executable_path = executable_path
+        if self.use_executable:
+            if not file_exists(self.executable_path):
+                raise FileNotFoundError(f"Executable not found {self.executable_path}")
+
+    def get_executable(self, use_system_interpreter: bool = False) -> str:
+        if self.use_executable:
+            return cast(str, self.executable_path)
+
+        p = self.PYTHON
+        if use_system_interpreter:
+            p = sys.executable
+        return f"{p} -m {self.name}"
+
+
+from typing import Optional, Union, List
+from abc import abstractmethod
+
+
+class QualityAssuranceRunner(Configurable, HasOptionalExecutable):
+    """
+    QualityAssuranceRunner is an abstract base class that handles the execution of quality assurance
+    processes. It extends Configurable and HasOptionalExecutable to incorporate configuration and
+    optional executable handling functionalities.
+
+    :param name: The name of the QA runner.
+    :param bound: The bound representing acceptable limits, either as a string or a Bound object.
+    :param target: The target to be tested, optional.
+    :param configuration_path: The path to the configuration file, optional.
+    :param executable_path: The path to the executable, optional.
+
+    Attributes:
+        bound (Bound): The bound object that represents the acceptable limits for the QA process.
+        target (Optional[str]): The target to be tested.
+    """
+
+    def __init__(
+            self, *,
+            name: str,
+            bound: Union[str, Bound],
+            target: Optional[str] = None,
+            configuration_path: Optional[str] = None,
+            executable_path: Optional[str] = None
+    ) -> None:
+        """
+        Initializes the QualityAssuranceRunner with the given parameters.
+
+        :param name: The name of the QA runner.
+        :param bound: The bound representing acceptable limits, either as a string or a Bound object.
+        :param target: The target to be tested, optional.
+        :param configuration_path: The path to the configuration file, optional.
+        :param executable_path: The path to the executable, optional.
+        """
+        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:
+        """
+        Builds the command to be executed for the QA process.
+
+        :param target: The target to be tested.
+        :param use_system_interpreter: Whether to use the system interpreter, default is False.
+        :return: The command to be executed as a string.
+        """
+
+    @abstractmethod
+    def _install_dependencies(self, base: LayeredCommand) -> None:
+        """
+        Installs the necessary dependencies for the QA process.
+
+        :param base: The base LayeredCommand object for executing commands.
+        """
+
+    def _pre_command(self) -> None:
+        """
+        Hook method to be executed before running the main command.
+        Can be overridden by subclasses.
+        """
+        pass
+
+    def _post_command(self) -> None:
+        """
+        Hook method to be executed after running the main command.
+        Can be overridden by subclasses.
+        """
+        pass
+
+    def run(self, target: str, executor: LayeredCommand, *, verbose: bool = True,  # type: ignore
+            use_system_interpreter: bool = False, print_func, env_name: str) -> None:
+        """
+        Runs the QA process on the specified target.
+
+        :param target: The target to be tested.
+        :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
+        # =====================================
+        command = self._build_command(target, use_system_interpreter)
+        self._pre_command()
+        try:
+            ret, out, err = executor(command, command_raise_on_fail=False)
+            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)
+        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:
+        """
+        Calculates the score based on the command's return code and output.
+
+        :param ret: The return code of the executed command.
+        :param command_output: The output of the command as a list of strings.
+        :param verbose: Whether to output verbose logs, default is False.
+        :return: The calculated score as a float.
+        """
+        ...
+
+
+__all__ = [
+    "QualityAssuranceRunner"
+]

quickpub-1.0.2/quickpub/strategies/upload_strategy.py → quickpub-1.0.3/quickpub/strategies/upload_target.py

@@ -3,7 +3,7 @@ from abc import abstractmethod
 from .quickpub_strategy import QuickpubStrategy
 
 
-class UploadStrategy(QuickpubStrategy):
+class UploadTarget(QuickpubStrategy):
     def __init__(self, verbose: bool = True) -> None:
         self.verbose = verbose
 
@@ -12,5 +12,5 @@ class UploadStrategy(QuickpubStrategy):
 
 
 __all__ = [
-    'UploadStrategy',
+    'UploadTarget',
 ]

{quickpub-1.0.2 → quickpub-1.0.3}/quickpub/structures/dependency.py

@@ -22,7 +22,7 @@ class Dependency:
             splits = s.split(op)
             if len(splits) == 2:
                 return Dependency(splits[0], op, Version.from_str(splits[-1]))  # type:ignore
-        raise ValueError("Invalid 'Dependency' format")
+        return Dependency(s, ">=", Version(0, 0, 0))
 
     def __str__(self) -> str:
         if self.ver == Version(0, 0, 0):

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: quickpub
-Version: 1.0.2
+Version: 1.0.3
 Summary: A python package to quickly configure and publish a new package
 Author-email: danielnachumdev <danielnachumdev@gmail.com>
 License: MIT License
@@ -34,35 +34,38 @@ Requires-Python: >=3.8.0
 Description-Content-Type: text/markdown
 License-File: LICENSE
 
-# quickpub V0.8.3
+# quickpub V1.0.3
 **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, AdditionalConfiguration, MypyRunner, PylintRunner, UnittestRunner
+from quickpub import publish, MypyRunner, PylintRunner, UnittestRunner, CondaPythonProvider, \
+    PypircUploadTarget, SetuptoolsBuildSchema, GithubUploadTarget
 
 
 def main() -> None:
     publish(
         name="quickpub",
-        version="0.8.0",
+        version="1.0.3",
         author="danielnachumdev",
         author_email="danielnachumdev@gmail.com",
         description="A python package to quickly configure and publish a new package",
         homepage="https://github.com/danielnachumdev/quickpub",
-        dependencies=["twine", "danielutils"],
-        min_python="3.9.19",
-        config=AdditionalConfiguration(
-            runners=[
-                MypyRunner(bound="<15"),
-                PylintRunner(bound=">=0.8"),
-                UnittestRunner(bound=">=0.8"),
-            ]
-        )
+        build_schemas=[SetuptoolsBuildSchema()],
+        upload_targets=[PypircUploadTarget(), GithubUploadTarget()],
+        python_interpreter_provider=CondaPythonProvider(["base", "390", "380"]),
+        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"],
+        min_python="3.8.0",
     )
 
 
 if __name__ == '__main__':
     main()
 
+
 ```

{quickpub-1.0.2 → quickpub-1.0.3}/quickpub.egg-info/SOURCES.txt

@@ -19,21 +19,21 @@ quickpub.egg-info/dependency_links.txt
 quickpub.egg-info/requires.txt
 quickpub.egg-info/top_level.txt
 quickpub/strategies/__init__.py
-quickpub/strategies/build_strategy.py
-quickpub/strategies/python_version_manager_strategy.py
-quickpub/strategies/quality_assurance_strategy.py
+quickpub/strategies/build_schema.py
+quickpub/strategies/python_provider.py
+quickpub/strategies/quality_assurance_runner.py
 quickpub/strategies/quickpub_strategy.py
-quickpub/strategies/upload_strategy.py
+quickpub/strategies/upload_target.py
 quickpub/strategies/implementations/__init__.py
 quickpub/strategies/implementations/conda_python_version_manager_strategy.py
-quickpub/strategies/implementations/git_upload_strategy.py
-quickpub/strategies/implementations/mypy_qa_strategy.py
-quickpub/strategies/implementations/pylint_qa_strategy.py
-quickpub/strategies/implementations/pypirc_upload_strategy.py
-quickpub/strategies/implementations/pytest_qa_strategy.py
-quickpub/strategies/implementations/setuptools_build_strategy.py
+quickpub/strategies/implementations/github_upload_target.py
+quickpub/strategies/implementations/mypy_qa_runner.py
+quickpub/strategies/implementations/pylint_qa_runner.py
+quickpub/strategies/implementations/pypirc_upload_target.py
+quickpub/strategies/implementations/pytest_qa_runner.py
+quickpub/strategies/implementations/setuptools_build_schema.py
 quickpub/strategies/implementations/system_interpreter.py
-quickpub/strategies/implementations/unittest_qa_strategy.py
+quickpub/strategies/implementations/unittest_qa_runner.py
 quickpub/structures/__init__.py
 quickpub/structures/bound.py
 quickpub/structures/dependency.py

quickpub-1.0.2/README.md

@@ -1,32 +0,0 @@
-# quickpub V0.8.3
-**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, AdditionalConfiguration, MypyRunner, PylintRunner, UnittestRunner
-
-
-def main() -> None:
-    publish(
-        name="quickpub",
-        version="0.8.0",
-        author="danielnachumdev",
-        author_email="danielnachumdev@gmail.com",
-        description="A python package to quickly configure and publish a new package",
-        homepage="https://github.com/danielnachumdev/quickpub",
-        dependencies=["twine", "danielutils"],
-        min_python="3.9.19",
-        config=AdditionalConfiguration(
-            runners=[
-                MypyRunner(bound="<15"),
-                PylintRunner(bound=">=0.8"),
-                UnittestRunner(bound=">=0.8"),
-            ]
-        )
-    )
-
-
-if __name__ == '__main__':
-    main()
-
-```

quickpub-1.0.2/quickpub/strategies/__init__.py

@@ -1,6 +0,0 @@
-from .implementations import *
-from .upload_strategy import *
-from .quality_assurance_strategy import *
-from .quickpub_strategy import *
-from .build_strategy import *
-from .python_version_manager_strategy import *

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

@@ -1,9 +0,0 @@
-from .pypirc_upload_strategy import *
-from .git_upload_strategy import *
-from .setuptools_build_strategy import *
-from .mypy_qa_strategy import *
-from .pylint_qa_strategy import *
-from .pytest_qa_strategy import *
-from .unittest_qa_strategy import *
-from .conda_python_version_manager_strategy import *
-from .system_interpreter import *

quickpub-1.0.2/quickpub/strategies/implementations/pytest_qa_strategy.py

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

quickpub-1.0.2/quickpub/strategies/quality_assurance_strategy.py

@@ -1,98 +0,0 @@
-import sys
-from abc import abstractmethod
-from typing import Union, List, Optional, cast
-from danielutils import LayeredCommand, get_os, OSType, file_exists
-
-from quickpub import Bound
-
-
-class Configurable:
-    @property
-    def has_config(self) -> bool:
-        return self.config_path is not None
-
-    def __init__(self, config_path: Optional[str] = None):
-        self.config_path = config_path
-        if self.has_config:
-            if not file_exists(self.config_path):
-                raise FileNotFoundError(f"Can't find config file {self.config_path}")
-
-
-class HasOptionalExecutable:
-    PYTHON: str = "python" if get_os() == OSType.WINDOWS else "python3"
-
-    @property
-    def use_executable(self) -> bool:
-        return self.executable_path is not None
-
-    def __init__(self, name, executable_path: Optional[str] = None) -> None:
-        self.name = name
-        self.executable_path = executable_path
-        if self.use_executable:
-            if not file_exists(self.executable_path):
-                raise FileNotFoundError(f"Executable not found {self.executable_path}")
-
-    def get_executable(self, use_system_interpreter: bool = False) -> str:
-        if self.use_executable:
-            return cast(str, self.executable_path)
-
-        p = self.PYTHON
-        if use_system_interpreter:
-            p = sys.executable
-        return f"{p} -m {self.name}"
-
-
-class QualityAssuranceStrategy(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, 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
-        from quickpub.proxy import os_system
-        from quickpub.enforcers import exit_if
-        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=False)
-            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 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__ = [
-    "QualityAssuranceStrategy"
-]