quickpub 1.0.0__tar.gz → 1.0.2__tar.gz

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

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

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

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

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

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

quickpub-1.0.2/quickpub/__main__.py

@@ -0,0 +1,169 @@
+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 .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
+
+
+def publish(
+        *,
+        name: str,
+        author: str,
+        author_email: str,
+        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(),
+
+        explicit_src_folder_path: Optional[str] = None,
+        version: Optional[Union[Version, str]] = None,
+        readme_file_path: str = "./README.md",
+        license_file_path: str = "./LICENSE",
+
+        min_python: Optional[Union[Version, str]] = None,
+
+        keywords: Optional[List[str]] = None,
+        dependencies: Optional[List[Union[str, Dependency]]] = 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.
+
+     :param name: The name of the package.
+     :param author: The name of the author.
+     :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 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".
+     :param license_file_path: The path to the license file. Defaults to "./LICENSE".
+     :param min_python: The minimum Python version required for the package. Defaults to the Python version running this script.
+     :param keywords: A list of keywords describing areas of interest for the package. Defaults to None.
+     :param dependencies: A list of dependencies for the package. Defaults to None.
+     :param demo: Whether to perform checks without making any changes. Defaults to False.
+     :param config: Reserved for future use. Defaults to None.
+
+     Returns:
+         None
+     """
+
+    enforce_pypirc_exists()
+    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_strategies is None:
+        quality_assurance_strategies = []
+    try:
+        res = qa(
+            python_version_manager_strategy,
+            quality_assurance_strategies,
+            name,
+            explicit_src_folder_path,
+            validated_dependencies
+        )
+        if not res:
+            error(f"quickpub.publish exited early as '{name}' "
+                  "did not pass quality assurance step, see above "
+                  "logs to pass this step.")
+            raise SystemExit(1)
+    except SystemExit as e:
+        raise e
+    except Exception as e:
+        raise RuntimeError("Quality assurance stage has failed") from e
+
+    create_setup()
+    create_toml(
+        name=name,
+        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,
+        description=description,
+        homepage=homepage,
+        keywords=keywords,
+        dependencies=validated_dependencies,
+        classifiers=[
+            DevelopmentStatusClassifier.Alpha,
+            IntendedAudienceClassifier.Developers,
+            ProgrammingLanguageClassifier.Python3,
+            OperatingSystemClassifier.MicrosoftWindows
+        ],
+        min_python=min_python
+    )
+    create_manifest(name=name)
+    if not demo:
+        for build_strategy in build_strategies:
+            build_strategy.execute_strategy()
+        for upload_strategy in upload_strategies:
+            upload_strategy.execute_strategy(name=name, version=version)
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="Publish a package")
+
+    parser.add_argument('--name', required=True, type=str, help='Name of the package')
+    parser.add_argument('--author', required=True, type=str, help='Author of the package')
+    parser.add_argument('--author_email', required=True, type=str, help='Email of the author')
+    parser.add_argument('--description', required=True, type=str, help='Description of the package')
+    parser.add_argument('--homepage', required=True, type=str, help='Homepage of the package')
+    parser.add_argument('--explicit_src_folder_path', type=str, help='Explicit source folder path')
+    parser.add_argument('--version', type=str, help='Version of the package')
+    parser.add_argument('--readme_file_path', type=str, default='./README.md', help='Path to the README file')
+    parser.add_argument('--license_file_path', type=str, default='./LICENSE', help='Path to the LICENSE file')
+    parser.add_argument('--min_python', type=str, help='Minimum Python version required')
+    parser.add_argument('--keywords', nargs='*', help='Keywords for the package')
+    parser.add_argument('--dependencies', nargs='*', help='Dependencies of the package')
+    parser.add_argument('--config', help='Additional configuration for the package')
+
+    return parser.parse_args()
+
+
+if __name__ == '__main__':
+    print("CLI is not currently supported")
+    # args = parse_args()
+    #
+    # publish(
+    #     name=args.name,
+    #     author=args.author,
+    #     author_email=args.author_email,
+    #     description=args.description,
+    #     homepage=args.homepage,
+    #     explicit_src_folder_path=args.explicit_src_folder_path,
+    #     version=args.version,
+    #     readme_file_path=args.readme_file_path,
+    #     license_file_path=args.license_file_path,
+    #     min_python=args.min_python,
+    #     keywords=args.keywords,
+    #     dependencies=args.dependencies,
+    #     config=args.config
+    # )

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

@@ -21,7 +21,7 @@ def _remove_suffix(s: str, suffix: str) -> str:
     :return: modified string
     """
     if get_python_version() >= (3, 9):
-        return s.removesuffix(suffix)
+        return s.removesuffix(suffix)  # type:ignore
     return _remove_prefix(s[::-1], suffix[::-1])[::-1]
 
 
@@ -33,7 +33,7 @@ def _remove_prefix(s: str, prefix: str) -> str:
     :return:
     """
     if get_python_version() >= (3, 9):
-        return s.removeprefix(prefix)
+        return s.removeprefix(prefix)  # type:ignore
 
     if s.startswith(prefix):
         return s[len(prefix):]

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

@@ -1,7 +1,8 @@
 from typing import List
 from danielutils import get_files
+
 from .classifiers import Classifier
-from .structures import Version
+from .structures import Version, Dependency
 
 
 def create_toml(
@@ -17,7 +18,7 @@ def create_toml(
         homepage: str,
         keywords: List[str],
         min_python: Version,
-        dependencies: List[str],
+        dependencies: List[Dependency],
         classifiers: List[Classifier]
 ) -> None:
     classifiers_string = ",\n\t".join([f"\"{str(c)}\"" for c in classifiers])
@@ -40,7 +41,7 @@ version = "{version}"
 authors = [
     {{ name = "{author}", email = "{author_email}" }},
 ]
-dependencies = {dependencies}
+dependencies = {[str(dep) for dep in dependencies]}
 keywords = {keywords}
 license = {{ "file" = "{license_file_path}" }}
 description = "{description}"

quickpub-1.0.2/quickpub/functions.py

@@ -0,0 +1,72 @@
+import sys
+from typing import Optional, Literal
+from danielutils import info
+
+from .enforcers import exit_if
+from .structures import Version
+import quickpub.proxy
+
+
+def build(
+        *,
+        verbose: bool = True
+) -> None:
+    if verbose:
+        info("Creating new distribution...")
+    ret, stdout, stderr = quickpub.proxy.cm("python", "setup.py", "sdist")
+    exit_if(
+        ret != 0,
+        stderr.decode(encoding="utf8")
+    )
+
+
+def upload(
+        *,
+        name: str,
+        version: Version,
+        verbose: bool = True
+) -> None:
+    if verbose:
+        info("Uploading")
+    ret, stdout, stderr = quickpub.proxy.cm("twine", "upload", "--config-file", ".pypirc",
+                                            f"dist/{name}-{version}.tar.gz")
+    exit_if(
+        ret != 0,
+        f"Failed uploading the package to pypi. Try running the following command manually:\n\ttwine upload --config-file .pypirc dist/{name}-{version}.tar.gz"
+    )
+
+
+def commit(
+        *,
+        version: Version,
+        verbose: bool = True
+) -> None:
+    if verbose:
+        info("Git")
+        info("\tStaging")
+    ret, stdout, stderr = quickpub.proxy.cm("git add .")
+    exit_if(
+        ret != 0,
+        stderr.decode(encoding="utf8")
+    )
+    if verbose:
+        info("\tCommitting")
+    ret, stdout, stderr = quickpub.proxy.cm(f"git commit -m \"updated to version {version}\"")
+    exit_if(
+        ret != 0,
+        stderr.decode(encoding="utf8")
+    )
+    if verbose:
+        info("\tPushing")
+    ret, stdout, stderr = quickpub.proxy.cm("git push")
+    exit_if(
+        ret != 0,
+        stderr.decode(encoding="utf8")
+    )
+
+
+__all__ = [
+    "build",
+    "upload",
+    "commit",
+]

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

@@ -1,16 +1,18 @@
+import re
 import sys
 from functools import wraps
-from typing import Optional, ContextManager, List, Callable
+from typing import Optional, ContextManager, List, Callable, Tuple, Dict, Union
 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 quickpub import QualityAssuranceStrategy
+from .strategies import PythonVersionManagerStrategy  # pylint: disable=relative-beyond-top-level
+from .structures import Dependency, Version, Bound  # pylint: disable=relative-beyond-top-level
 from .enforcers import exit_if  # pylint: disable=relative-beyond-top-level
 
 try:
     from danielutils import MultiContext  # type:ignore
 except ImportError:
-    class MultiContext(ContextManager):  # pylint: disable=missing-class-docstring #type:ignore
+    class MultiContext(ContextManager):  # type: ignore # pylint: disable=missing-class-docstring
         def __init__(self, *contexts: ContextManager):
             self.contexts = contexts
 
@@ -49,12 +51,16 @@ def global_import_sanity_check(package_name: str, executor: LayeredCommand, is_s
                 verbose=True, err_func=err_print_func)
 
 
-def validate_dependencies(python_manager: PythonManager, dependencies: List[str], executor: LayeredCommand,
+VERSION_REGEX: re.Pattern = re.compile(r"^\d+\.\d+\.\d+$")
+
+
+def validate_dependencies(python_manager: PythonVersionManagerStrategy, required_dependencies: List[Dependency],
+                          executor: LayeredCommand,
                           env_name: str, err_print_func: Callable) -> None:
     """
     will check if all the dependencies of the package are installed on current env.
     :param python_manager: the manager to use
-    :param dependencies: the dependencies to check
+    :param required_dependencies: the dependencies to check
     :param executor: the current LayeredCommand executor
     :param env_name: name of the currently checked environment
     :param err_print_func: function to print errors
@@ -63,23 +69,46 @@ def validate_dependencies(python_manager: PythonManager, dependencies: List[str]
     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}",
+        split_lines = (line.split(' ') for line in out[2:])
+        version_tuples = [(s[0], s[-1].strip()) for s in split_lines]
+        filtered_tuples = [t for t in version_tuples if VERSION_REGEX.match(t[1])]
+        currently_installed: Dict[str, Union[str, Dependency]] = {s[0]: Dependency(s[0], "==", Version.from_str(s[-1]))
+                                                                  for s in filtered_tuples}
+        currently_installed.update(**{t[0]: t[1] for t in version_tuples if not VERSION_REGEX.match(t[1])})
+        not_installed_properly: List[Tuple[Dependency, str]] = []
+        for req in required_dependencies:
+            if req.name not in currently_installed:
+                not_installed_properly.append((req, "dependency not found"))
+            else:
+                v = currently_installed[req.name]
+                if isinstance(v, str):
+                    not_installed_properly.append(
+                        (req, "Verion format of dependecy is not currently supported by quickpub"))
+                elif isinstance(v, Dependency):
+                    if not req.is_satisfied_by(v.ver):
+                        not_installed_properly.append((req, "rInvalid 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(config, python_manager) -> ProgressBarPool:
+def create_progress_bar_pool(python_version_manager: PythonVersionManagerStrategy,
+                             quality_assurance_strategies: List[QualityAssuranceStrategy]) -> 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 [])),
+            dict(
+                iterator=python_version_manager,
+                desc="Envs",
+                total=len(python_version_manager.requested_envs)
+            ),
+            dict(
+                iterator=quality_assurance_strategies or [],
+                desc="Runners",
+                total=len(quality_assurance_strategies or [])
+            ),
         ]
     )
 
@@ -93,18 +122,19 @@ def create_pool_print_error(pool: ProgressBarPool):
     return func
 
 
-def qa(package_name: str, config: Optional[AdditionalConfiguration], src_folder_path: Optional[str],
-       dependencies: list) -> bool:
-    if config is None:
-        return True
+def qa(
+        python_version_manager: PythonVersionManagerStrategy,
+        quality_assurance_strategies: List[QualityAssuranceStrategy],
+        package_name: str,
+        src_folder_path: Optional[str],
+        dependencies: list
+) -> bool:
+    from .strategies import SystemInterpreter
     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)
+    if python_version_manager is None:
+        python_version_manager = SystemInterpreter()
+    is_system_interpreter = isinstance(python_version_manager, SystemInterpreter)
+    pool = create_progress_bar_pool(python_version_manager, quality_assurance_strategies)
     pool_err = create_pool_print_error(pool)
     with MultiContext(
             AttrContext(LayeredCommand, 'class_flush_stdout', False),
@@ -118,7 +148,7 @@ def qa(package_name: str, config: Optional[AdditionalConfiguration], src_folder_
             with executor:
                 executor._prev_instance = base
                 try:
-                    validate_dependencies(python_manager, dependencies, executor, env_name, pool_err)
+                    validate_dependencies(python_version_manager, dependencies, executor, env_name, pool_err)
                 except SystemExit:
                     result = False
                     continue
@@ -135,7 +165,7 @@ def qa(package_name: str, config: Optional[AdditionalConfiguration], src_folder_
                             src_folder_path,
                             executor,
                             use_system_interpreter=is_system_interpreter,
-                            raise_on_fail=python_manager.exit_on_fail,
+                            raise_on_fail=python_version_manager.exit_on_fail,
                             print_func=pool_err,
                             env_name=env_name
                         )
@@ -149,8 +179,8 @@ def qa(package_name: str, config: Optional[AdditionalConfiguration], src_folder_
                             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
+                        if python_version_manager.exit_on_fail:
+                            raise RuntimeError() from e
     return result
 
 

quickpub-1.0.2/quickpub/strategies/__init__.py

@@ -0,0 +1,6 @@
+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/build_strategy.py

@@ -0,0 +1,16 @@
+from abc import abstractmethod
+
+from .quickpub_strategy import QuickpubStrategy
+
+
+class BuildStrategy(QuickpubStrategy):
+    def __init__(self, verbose: bool = True) -> None:
+        self.verbose = verbose
+
+    @abstractmethod
+    def execute_strategy(self, *args, **kwargs) -> None: ...
+
+
+__all__ = [
+    "BuildStrategy"
+]

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

@@ -0,0 +1,9 @@
+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.0/quickpub/managers/implementations/conda.py → quickpub-1.0.2/quickpub/strategies/implementations/conda_python_version_manager_strategy.py

@@ -1,15 +1,15 @@
-from typing import Tuple, Optional, Set, Iterator
+from typing import Tuple, Optional, Set, Iterator, List
 from danielutils import LayeredCommand, warning
 
-from ..python_manager import PythonManager
+from ..python_version_manager_strategy import PythonVersionManagerStrategy
 
 
-class CondaPythonManager(PythonManager):
+class CondaPythonVersionManagerStrategy(PythonVersionManagerStrategy):
     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=[])
+    def __init__(self, env_names: List[str]) -> None:
+        PythonVersionManagerStrategy.__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 CondaPythonManager(PythonManager):
 
 
 __all__ = [
-    'CondaPythonManager',
+    'CondaPythonVersionManagerStrategy',
 ]

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

@@ -0,0 +1,26 @@
+from danielutils import info
+
+from ..upload_strategy import UploadStrategy
+
+class GitUploadStrategy(UploadStrategy):
+    def execute_strategy(self, version: str, **kwargs) -> None:
+        from quickpub.proxy import cm
+        from quickpub.enforcers import exit_if
+        if self.verbose:
+            info("Git")
+            info("\tStaging")
+        ret, stdout, stderr = cm("git add .")
+        exit_if(ret != 0, stderr.decode(encoding="utf8"))
+        if self.verbose:
+            info("\tCommitting")
+        ret, stdout, stderr = cm(f"git commit -m \"updated to version {version}\"")
+        exit_if(ret != 0, stderr.decode(encoding="utf8"))
+        if self.verbose:
+            info("\tPushing")
+        ret, stdout, stderr = cm("git push")
+        exit_if(ret != 0, stderr.decode(encoding="utf8"))
+
+
+__all__ = [
+    "GitUploadStrategy",
+]

quickpub-1.0.0/quickpub/runnables/implementations/mypy.py → quickpub-1.0.2/quickpub/strategies/implementations/mypy_qa_strategy.py

@@ -3,10 +3,10 @@ from typing import Optional, List
 
 from danielutils import LayeredCommand
 
-from ..base_runner import BaseRunner
+from ..quality_assurance_strategy import QualityAssuranceStrategy
 
 
-class MypyRunner(BaseRunner):
+class MypyRunner(QualityAssuranceStrategy):
     def _install_dependencies(self, base: LayeredCommand) -> None:
         with base:
             base("pip install pylint")
@@ -23,8 +23,8 @@ class MypyRunner(BaseRunner):
 
     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)
+        QualityAssuranceStrategy.__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
@@ -32,7 +32,7 @@ class MypyRunner(BaseRunner):
         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')}",
+                f"Failed running MyPy, got exit code {ret}. try running manually using: {self._build_command('TARGET')}",
                 verbose=verbose)
         num_failed = float(m.group(1))
         active_files = float(m.group(2))

quickpub-1.0.0/quickpub/runnables/implementations/pylint.py → quickpub-1.0.2/quickpub/strategies/implementations/pylint_qa_strategy.py

@@ -3,10 +3,10 @@ from typing import Optional, List
 
 from danielutils import LayeredCommand
 
-from ..base_runner import BaseRunner
+from strategies.quality_assurance_strategy import QualityAssuranceStrategy
 
 
-class PylintRunner(BaseRunner):
+class PylintRunner(QualityAssuranceStrategy):
     def _install_dependencies(self, base: LayeredCommand) -> None:
         with base:
             base("pip install pylint")
@@ -15,8 +15,8 @@ class PylintRunner(BaseRunner):
 
     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)
+        QualityAssuranceStrategy.__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()
@@ -28,10 +28,13 @@ class PylintRunner(BaseRunner):
     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]
+            raise RuntimeError("No module named pylint found")
+        index = -2
+        if lines[-1] == '\x1b[0m':
+            index += -1
+        rating_line = lines[index]
         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')}"
+        msg = f"Failed running Pylint, got exit code {ret}. Try running manually using: {self._build_command('TARGET')}"
         exit_if(not m, msg)
         rating_string = m.group(1)  # type:ignore
         numerator, denominator = rating_string.split("/")