quickpub 1.0.2__tar.gz → 2.0.0__tar.gz

{quickpub-1.0.2 → quickpub-2.0.0}/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-2.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: quickpub
-Version: 1.0.2
+Version: 2.0.0
 Summary: A python package to quickly configure and publish a new package
 Author-email: danielnachumdev <danielnachumdev@gmail.com>
 License: MIT License
@@ -34,35 +34,43 @@ 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, PypircEnforcer, ReadmeEnforcer, LicenseEnforcer,
+    PypiRemoteVersionEnforcer, LocalVersionEnforcer
 
 
 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"),
-            ]
-        )
+        enforcers=[
+            PypircEnforcer(), ReadmeEnforcer(), LicenseEnforcer(),
+            LocalVersionEnforcer(), PypiRemoteVersionEnforcer()
+        ],
+        build_schemas=[SetuptoolsBuildSchema()],
+        upload_targets=[PypircUploadTarget(), GithubUploadTarget()],
+        python_interpreter_provider=CondaPythonProvider(["base", "390", "380"]),
+        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.92", "requests"],
+        min_python="3.8.0",
+        demo=True
     )
 
 
 if __name__ == '__main__':
     main()
-
 ```

quickpub-2.0.0/README.md

@@ -0,0 +1,40 @@
+# 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, PypircEnforcer, ReadmeEnforcer, LicenseEnforcer,
+    PypiRemoteVersionEnforcer, LocalVersionEnforcer
+
+
+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",
+        enforcers=[
+            PypircEnforcer(), ReadmeEnforcer(), LicenseEnforcer(),
+            LocalVersionEnforcer(), PypiRemoteVersionEnforcer()
+        ],
+        build_schemas=[SetuptoolsBuildSchema()],
+        upload_targets=[PypircUploadTarget(), GithubUploadTarget()],
+        python_interpreter_provider=CondaPythonProvider(["base", "390", "380"]),
+        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.92", "requests"],
+        min_python="3.8.0",
+        demo=True
+    )
+
+
+if __name__ == '__main__':
+    main()
+```

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

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

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

@@ -2,14 +2,13 @@ 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, 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
 
 
@@ -21,22 +20,21 @@ 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],
+        enforcers: Optional[List[ConstraintEnforcer]] = None,
+        global_quality_assurance_runners: Optional[List[QualityAssuranceRunner]] = None,
+        python_interpreter_provider: PythonProvider = DefaultPythonProvider(),
 
-        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,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_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 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 <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".
@@ -63,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_strategies is None:
-        quality_assurance_strategies = []
+    for enforcer in enforcers or []:
+        enforcer.enforce(name=name, version=version, demo=demo)
+
     try:
         res = qa(
-            python_version_manager_strategy,
-            quality_assurance_strategies,
+            python_interpreter_provider,
+            global_quality_assurance_runners or [],
             name,
             explicit_src_folder_path,
             validated_dependencies
@@ -122,10 +114,10 @@ def publish(
     )
     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)
+        for schema in build_schemas:
+            schema.build()
+        for target in upload_targets:
+            target.upload(name=name, version=version)
 
 
 def parse_args():

{quickpub-1.0.2 → quickpub-2.0.0}/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.0/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.2 → quickpub-2.0.0}/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.2 → quickpub-2.0.0}/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,18 +122,16 @@ def create_pool_print_error(pool: ProgressBarPool):
 
 
 def qa(
-        python_version_manager: PythonVersionManagerStrategy,
-        quality_assurance_strategies: List[QualityAssuranceStrategy],
+        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 SystemInterpreter
+    from .strategies import DefaultPythonProvider
     result = True
-    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)
+    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),
@@ -148,7 +145,7 @@ def qa(
             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
@@ -165,7 +162,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
                         )
@@ -179,7 +175,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-2.0.0/quickpub/strategies/__init__.py

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

quickpub-1.0.2/quickpub/strategies/upload_strategy.py → quickpub-2.0.0/quickpub/strategies/build_schema.py

@@ -1,16 +1,17 @@
 from abc import abstractmethod
+from typing import Type
 
 from .quickpub_strategy import QuickpubStrategy
 
 
-class UploadStrategy(QuickpubStrategy):
+class BuildSchema(QuickpubStrategy):
     def __init__(self, verbose: bool = True) -> None:
         self.verbose = verbose
 
     @abstractmethod
-    def execute_strategy(self, *args, **kwargs) -> None: ...
+    def build(self, *args, **kwargs) -> None: ...
 
 
 __all__ = [
-    'UploadStrategy',
+    "BuildSchema"
 ]

quickpub-2.0.0/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.0/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.0/quickpub/strategies/implementations/build_schemas/__init__.py

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

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

@@ -0,0 +1,27 @@
+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("", instance_flush_stdout=False, instance_flush_stderr=False,
+                            instance_raise_on_fail=False) 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.0/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.0/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.0/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.0/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'
+]