quickpub 0.5.0__tar.gz → 0.8.0__tar.gz

quickpub-0.8.0/LICENSE

@@ -0,0 +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
+SOFTWARE.

quickpub-0.8.0/MANIFEST.in

@@ -0,0 +1 @@
+recursive-include quickpub *.py

{quickpub-0.5.0 → quickpub-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: quickpub
-Version: 0.5.0
+Version: 0.8.0
 Summary: A python package to quickly configure and publish a new package
 Author-email: danielnachumdev <danielnachumdev@gmail.com>
 License: MIT License
@@ -30,7 +30,38 @@ Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: Programming Language :: Python :: 3
 Classifier: Operating System :: Microsoft :: Windows
-Requires-Python: >=3.10.13
+Requires-Python: >=3.9.19
 Description-Content-Type: text/markdown
+License-File: LICENSE
 
 # quickpub
+
+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(),
+                PylintRunner(),
+                UnittestRunner(),
+            ]
+        )
+    )
+
+
+if __name__ == '__main__':
+    main()
+
+```

quickpub-0.8.0/README.md

@@ -0,0 +1,31 @@
+# quickpub
+
+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(),
+                PylintRunner(),
+                UnittestRunner(),
+            ]
+        )
+    )
+
+
+if __name__ == '__main__':
+    main()
+
+```

{quickpub-0.5.0 → quickpub-0.8.0}/pyproject.toml

@@ -4,16 +4,16 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "quickpub"
-version = "0.5.0"
+version = "0.8.0"
 authors = [
     { name = "danielnachumdev", email = "danielnachumdev@gmail.com" },
 ]
 dependencies = ['twine', 'danielutils']
 keywords = []
-license = { "file" = "LISENCE" }
+license = { "file" = "./LICENSE" }
 description = "A python package to quickly configure and publish a new package"
-readme = "README.md"
-requires-python = ">=3.10.13"
+readme = {file = "./README.md", content-type = "text/markdown"}
+requires-python = ">=3.9.19"
 classifiers = [
 	"Development Status :: 3 - Alpha",
 	"Intended Audience :: Developers",
@@ -23,6 +23,8 @@ classifiers = [
 
 [tool.setuptools]
 packages = ["quickpub"]
+[tool.setuptools.package-data]
+"quickpub" = ["py.typed"]
 
 [project.urls]
 "Homepage" = "https://github.com/danielnachumdev/quickpub"

quickpub-0.8.0/quickpub/__init__.py

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

quickpub-0.8.0/quickpub/__main__.py

@@ -0,0 +1,102 @@
+from typing import Optional, Union
+from danielutils import warning, file_exists
+from .validators import validate_version, validate_python_version, validate_keywords, validate_dependencies, \
+    validate_source
+from .functions import build, upload, commit, metrics
+from .structures import Version, AdditionalConfiguration
+from .files import create_toml, create_setup, create_manifest
+from .classifiers import *
+from .enforcers import enforce_local_correct_version, enforce_pypirc_exists, exit_if, enforce_remote_correct_version
+from .custom_types import Path
+
+
+def publish(
+        *,
+        name: str,
+        author: str,
+        author_email: str,
+        description: str,
+        homepage: str,
+        src: Optional[Path] = None,
+        version: Optional[Union[Version, str]] = None,
+        readme: Path = "./README.md",
+        license: Path = "./LICENSE",
+
+        min_python: Optional[Union[Version, str]] = None,
+
+        keywords: Optional[list[str]] = None,
+        dependencies: Optional[list[str]] = None,
+        config: Optional[AdditionalConfiguration] = None
+) -> None:
+    """The main function of this package. will do all the heavy lifting in order for you to publish your package.
+
+    Args:
+        name (str): The name of the package
+        author (str): The name of the author
+        author_email (str): The email of the author
+        description (str): A short description for the package
+        homepage (str): The homepage for the package. URL to the github repo is a good option.
+        src (Optional[Path], optional): The path to the source code of the package. if None defaults to CWD/<name>
+        version (Optional[Union[Version, str]], optional): The version to create the new distribution. if None defaults to 0.0.1
+        readme (Path, optional): The path to the readme file. Defaults to "./README.md".
+        license (Path, optional): The path to the license file . Defaults to "./LICENSE".
+        min_python (Optional[Union[Version, str]], optional): The minimum version of python required for this package to run. Defaults to the version of python running this script.
+        keywords (Optional[list[str]], optional): A list of keywords to describe areas of interests of this package. Defaults to None.
+        dependencies (Optional[list[str]], optional): A list of the dependencies for this package. Defaults to None.
+        config (Optional[Config], optional): reserved for future use. Defaults to None.
+    """
+    enforce_pypirc_exists()
+    src = validate_source(name, src)
+    if src != f"./{name}":
+        warning(
+            "The source folder's name is different from the package's name. this may not be currently supported correctly")
+    exit_if(not file_exists(readme), f"Could not find readme file at {readme}")
+    exit_if(not file_exists(license),
+            f"Could not find license file at {license}")
+    version = validate_version(version)
+    enforce_local_correct_version(name, version)
+    min_python = validate_python_version(min_python)  # type:ignore
+    keywords = validate_keywords(keywords)
+    dependencies = validate_dependencies(dependencies)
+    enforce_remote_correct_version(name, version)
+
+    if config is not None:
+        if config.runners is not None:
+            for runner in config.runners:
+                runner.run(src)
+
+    create_setup()
+    create_toml(
+        name=name,
+        src=src,
+        readme=readme,
+        license=license,
+        version=version,
+        author=author,
+        author_email=author_email,
+        description=description,
+        homepage=homepage,
+        keywords=keywords,
+        dependencies=dependencies,
+        classifiers=[
+            DevelopmentStatusClassifier.Alpha,
+            IntendedAudienceClassifier.Developers,
+            ProgrammingLanguageClassifier.Python3,
+            OperatingSystemClassifier.MicrosoftWindows
+        ],
+        min_python=min_python
+    )
+    create_manifest(name=name)
+
+    build()
+    upload(
+        name=name,
+        version=version
+    )
+    commit(
+        version=version
+    )
+    metrics()
+
+# if __name__ == '__main__':
+#     publish()

quickpub-0.8.0/quickpub/custom_types.py

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

quickpub-0.8.0/quickpub/enforcers.py

@@ -0,0 +1,58 @@
+import sys
+from typing import Union, Callable
+
+import requests
+# from bs4 import BeautifulSoup
+from danielutils import directory_exists, get_files, error, file_exists
+from .structures import Version
+from .proxy import get
+
+
+def exit_if(predicate: Union[bool, Callable[[], bool]], msg: str) -> None:
+    if (isinstance(predicate, bool) and predicate) or (callable(predicate) and predicate()):
+        error(msg)
+        sys.exit(1)
+
+
+def enforce_local_correct_version(name: str, version: Version) -> None:
+    if directory_exists("./dist"):
+        max_version = Version(0, 0, 0)
+        for d in get_files("./dist"):
+            d = d.removeprefix(f"{name}-").removesuffix(".tar.gz")
+            v = Version.from_str(d)
+            max_version = max(max_version, v)
+        exit_if(
+            version <= max_version,
+            f"Specified version is '{version}' but (locally available) latest existing is '{max_version}'"
+        )
+
+
+def enforce_remote_correct_version(name: str, version: Version) -> None:
+    pass
+    # url = f"https://pypi.org/project/{name}/#history"
+    # headers = {
+    #     "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36"
+    # }
+    # response = requests.get(url, headers=headers)
+    # if response.status_code != 200:
+    #     return
+    # soup = BeautifulSoup(response.text, "html.parser")
+    # divs = soup.find_all("div", class_="release")
+    # versions = []
+    # for div in divs:
+    #     ver = div.find("p", class_="release__version").text.strip()
+    #     versions.append(ver)
+    # pass
+
+
+def enforce_pypirc_exists() -> None:
+    exit_if(
+        not file_exists("./.pypirc"),
+        "No .pypirc file found"
+    )
+
+
+__all__ = [
+    "enforce_local_correct_version",
+    "enforce_pypirc_exists"
+]

{quickpub-0.5.0 → quickpub-0.8.0}/quickpub/files.py

@@ -1,12 +1,15 @@
-from typing import Optional
-
+from .custom_types import Path
 from .classifiers import Classifier
 from .structures import Version
+from danielutils import get_files
 
 
 def create_toml(
         *,
         name: str,
+        src: Path,
+        readme: Path,
+        license: Path,
         version: Version,
         author: str,
         author_email: str,
@@ -20,6 +23,13 @@ def create_toml(
     classifiers_string = ",\n\t".join([f"\"{str(c)}\"" for c in classifiers])
     if len(classifiers_string) > 0:
         classifiers_string = f"\n\t{classifiers_string}\n"
+    py_typed = ""
+    for file in get_files(src):
+        if file == "py.typed":
+            py_typed = f"""[tool.setuptools.package-data]
+"{name}" = ["py.typed"]"""
+            break
+
     s = f"""[build-system]
 requires = ["setuptools>=61.0"]
 build-backend = "setuptools.build_meta"
@@ -32,14 +42,15 @@ authors = [
 ]
 dependencies = {dependencies}
 keywords = {keywords}
-license = {{ "file" = "LISENCE" }}
+license = {{ "file" = "{license}" }}
 description = "{description}"
-readme = "README.md"
+readme = {{file = "{readme}", content-type = "text/markdown"}}
 requires-python = ">={min_python}"
 classifiers = [{classifiers_string}]
 
 [tool.setuptools]
 packages = ["{name}"]
+{py_typed}
 
 [project.urls]
 "Homepage" = "{homepage}"
@@ -52,7 +63,9 @@ packages = ["{name}"]
 def create_setup() -> None:
     with open("./setup.py", "w", encoding="utf8") as f:
         f.write("from setuptools import setup\n\nsetup()\n")
-
+def create_manifest(*,name:str)->None:
+    with open("./MANIFEST.in", "w", encoding="utf8") as f:
+        f.write(f"recursive-include {name} *.py")
 
 __all__ = [
     "create_setup",

quickpub-0.5.0/quickpub/publish.py → quickpub-0.8.0/quickpub/functions.py

@@ -1,7 +1,12 @@
-from danielutils import info, error
+import sys
+from typing import Optional, Literal
+from danielutils import info
 
-from .proxy import cm
+from .enforcers import exit_if
 from .structures import Version
+import quickpub.proxy
+
+
 
 
 def prev_main():
@@ -147,10 +152,11 @@ def build(
 ) -> None:
     if verbose:
         info("Creating new distribution...")
-    ret, stdout, stderr = cm("python", "setup.py", "sdist")
-    if ret != 0:
-        error(stderr.decode(encoding="utf8"))
-        exit(1)
+    ret, stdout, stderr = quickpub.proxy.cm("python", "setup.py", "sdist")
+    exit_if(
+        ret != 0,
+        stderr.decode(encoding="utf8")
+    )
 
 
 def upload(
@@ -161,10 +167,12 @@ def upload(
 ) -> None:
     if verbose:
         info("Uploading")
-    ret, stdout, stderr = cm("wt.exe", "twine", "upload", "--config-file", ".pypirc", f"dist/{name}-{version}.tar.gz")
-    if ret != 0:
-        error(stderr.decode(encoding="utf8"))
-        exit(1)
+    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(
@@ -175,16 +183,28 @@ def commit(
     if verbose:
         info("Git")
         info("\tStaging")
-    cm("git add .")
+    ret, stdout, stderr = quickpub.proxy.cm("git add .")
+    exit_if(
+        ret != 0,
+        stderr.decode(encoding="utf8")
+    )
     if verbose:
         info("\tCommitting")
-    cm(f"git commit -m \"updated to version {version}\"")
+    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")
-    cm("git push")
+    ret, stdout, stderr = quickpub.proxy.cm("git push")
+    exit_if(
+        ret != 0,
+        stderr.decode(encoding="utf8")
+    )
 
 
-def metrics():
+def metrics(testing_client: Optional[Literal["pytest", "unitest"]] = None):
     pass
 
 

quickpub-0.8.0/quickpub/proxy.py

@@ -0,0 +1,26 @@
+import danielutils
+import requests
+
+
+# need it like this for the testing
+def cm(*args, **kwargs) -> tuple[int, bytes, bytes]:
+    return danielutils.cm(*args, **kwargs)
+
+
+def get(*args, **kwargs):
+    return requests.get(*args, **kwargs)
+
+
+def add_verbose_keyword(func):
+    def wrapper(*args, verbose: bool = False, **kwargs):
+        if verbose:
+            return func(*args, **kwargs)
+
+    return wrapper
+
+
+__all__ = [
+    "cm",
+    "get",
+    'add_verbose_keyword'
+]

quickpub-0.8.0/quickpub/runnables/__init__.py

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

quickpub-0.8.0/quickpub/runnables/common_check.py

@@ -0,0 +1,57 @@
+import os
+from abc import abstractmethod
+from typing import Optional, Union
+
+from danielutils import file_exists, cm, info, get_current_working_directory, set_current_working_directory
+
+from .has_optional_executable import HasOptionalExecutable
+from .runnable import Runnable
+from .configurable import Configurable
+from ..structures import Bound
+
+
+class CommonCheck(Runnable, Configurable, HasOptionalExecutable):
+
+    def __init__(self, name: str, bound: Union[str, Bound], target: Optional[str] = None,
+                 configuration_path: Optional[str] = None,
+                 executable_path: Optional[str] = None) -> None:
+        Configurable.__init__(self, configuration_path)
+        HasOptionalExecutable.__init__(self, name, executable_path)
+        self.bound: Bound = bound if isinstance(bound, Bound) else Bound.from_string(bound)
+        self.target = target
+
+    def _build_command(self, target: str) -> str:
+        command: str = self.get_executable()
+        if self.has_config:
+            command += f" --rcfile {self.config_path}"
+        command += f" {target}"
+        return command
+
+    @abstractmethod
+    def _pre_command(self):
+        ...
+
+    @abstractmethod
+    def _post_command(self):
+        ...
+
+    def run(self, target: str, *_) -> None:
+        command = self._build_command(target)
+        info(f"Running {self.name}")
+        self._pre_command()
+        try:
+            ret, out, err = cm(command)
+            score = self._calculate_score(ret, b"".join([out, err]).decode("utf-8").splitlines())
+            from ..enforcers import exit_if
+            exit_if(not self.bound.compare_against(score), f"{self.name} failed to pass it's defined bound")
+        finally:
+            self._post_command()
+
+
+@abstractmethod
+def _calculate_score(self, ret: int, command_output: list[str]) -> float: ...
+
+
+__all__ = [
+    "CommonCheck"
+]

quickpub-0.8.0/quickpub/runnables/configurable.py

@@ -0,0 +1,20 @@
+from abc import ABC
+from typing import Optional
+from danielutils import file_exists
+
+
+class Configurable(ABC):
+    @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}")
+
+
+__all__ = [
+    "Configurable",
+]

quickpub-0.8.0/quickpub/runnables/has_optional_executable.py

@@ -0,0 +1,27 @@
+from typing import Any, Protocol, Optional
+from danielutils import get_os, OSType, file_exists
+
+
+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) -> str:
+        if self.use_executable:
+            return self.executable_path
+        return f"{self.PYTHON} -m {self.name}"
+
+
+__all__ = [
+    'HasOptionalExecutable',
+]

quickpub-0.8.0/quickpub/runnables/implementations/__init__.py

@@ -0,0 +1,4 @@
+from .mypy import *
+from .pylint import *
+from .pytest import *
+from .unittest import *

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

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

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

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

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

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

quickpub-0.8.0/quickpub/runnables/implementations/unittest.py

@@ -0,0 +1,50 @@
+import re
+import os
+from typing import Optional
+from danielutils import get_current_working_directory, set_current_working_directory
+from ..common_check import CommonCheck
+
+
+class UnittestRunner(CommonCheck):
+    def _pre_command(self):
+        self._cwd = get_current_working_directory()
+        set_current_working_directory(os.path.join(self._cwd, self.target))
+
+    def _post_command(self):
+        set_current_working_directory(self._cwd)
+
+    RATING_PATTERN: re.Pattern = re.compile(r".*?([\d\.\/]+)")
+
+    def __init__(self, target: Optional[str] = "./tests") -> None:
+        CommonCheck.__init__(self, "unittest", ">=0.7", target)
+        self._cwd = ""
+
+    def _build_command(self, src: str, *args) -> str:
+        command: str = self.get_executable()
+        rel = os.path.relpath(src, self.target).removesuffix(src.lstrip("./\\"))
+        command += f" discover -s {rel}"
+        return command  # f"cd {self.target}; {command}"  # f"; cd {self.target}"
+
+    def _calculate_score(self, ret: int, lines: list[str]) -> float:
+        from ...enforcers import exit_if
+        num_tests_line = lines[-3]
+        num_failed_line = lines[-1] if lines[-1] != "OK" else "0"
+        try:
+            m = self.RATING_PATTERN.match(num_tests_line)
+            if not m:
+                raise AssertionError
+            num_tests = m.group(1)
+            m = self.RATING_PATTERN.match(num_failed_line)
+            if not m:
+                raise AssertionError
+            num_failed = m.group(1)
+
+            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:\n\t{self._build_command('TARGET')}")
+
+
+__all__ = [
+    'UnittestRunner',
+]

quickpub-0.8.0/quickpub/runnables/runnable.py

@@ -0,0 +1,11 @@
+from abc import ABC, abstractmethod
+
+
+class Runnable(ABC):
+    @abstractmethod
+    def run(self, *args, **kwargs) -> float: ...
+
+
+__all__ = [
+    "Runnable"
+]

quickpub-0.8.0/quickpub/structures/__init__.py

@@ -0,0 +1,3 @@
+from .bound import *
+from .version import *
+from .additional_configuration import *

quickpub-0.8.0/quickpub/structures/additional_configuration.py

@@ -0,0 +1,13 @@
+from dataclasses import dataclass
+from typing import Optional
+from ..runnables import Runnable
+
+
+@dataclass(frozen=True)
+class AdditionalConfiguration:
+    runners: Optional[list[Runnable]]
+
+
+__all__ = [
+    'AdditionalConfiguration',
+]

quickpub-0.8.0/quickpub/structures/bound.py

@@ -0,0 +1,30 @@
+from dataclasses import dataclass
+from typing import Literal
+
+
+@dataclass
+class Bound:
+    operator: Literal["<", "<=", ">", ">="]
+    value: float
+
+    def compare_against(self, score: float) -> bool:
+        return {
+            ">": score > self.value,
+            ">=": score >= self.value,
+            "<": score < self.value,
+            "<=": score <= self.value,
+        }[self.operator]
+
+    @staticmethod
+    def from_string(s: str) -> 'Bound':
+        # the order of iteration matters, weak inequality operators should be first.
+        for op in [">=", "<=", ">", "<"]:
+            splits = s.split(op)
+            if len(splits) == 2:
+                return Bound(op, float(splits[-1]))  # type:ignore
+        raise ValueError("Invalid 'Bound' format")
+
+
+__all__ = [
+    'Bound'
+]

quickpub-0.8.0/quickpub/structures/version.py

@@ -0,0 +1,27 @@
+from dataclasses import dataclass
+
+
+@dataclass(order=True)
+class Version:
+    @staticmethod
+    def from_str(version_str: str) -> "Version":
+        return Version(*list(map(int, version_str.split("."))))
+
+    major: int = 0
+    minor: int = 0
+    patch: int = 0
+
+    def __init__(self, major: int = 0, minor: int = 0, patch: int = 0):
+        if not all(map(lambda x: isinstance(x, int) and x >= 0, [major, minor, patch])):
+            raise ValueError("Version supports positive integers only")
+        self.major = major
+        self.minor = minor
+        self.patch = patch
+
+    def __str__(self) -> str:
+        return f"{self.major}.{self.minor}.{self.patch}"
+
+
+__all__ = [
+    'Version'
+]

quickpub-0.8.0/quickpub/validators.py

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

{quickpub-0.5.0 → quickpub-0.8.0}/quickpub.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: quickpub
-Version: 0.5.0
+Version: 0.8.0
 Summary: A python package to quickly configure and publish a new package
 Author-email: danielnachumdev <danielnachumdev@gmail.com>
 License: MIT License
@@ -30,7 +30,38 @@ Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: Programming Language :: Python :: 3
 Classifier: Operating System :: Microsoft :: Windows
-Requires-Python: >=3.10.13
+Requires-Python: >=3.9.19
 Description-Content-Type: text/markdown
+License-File: LICENSE
 
 # quickpub
+
+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(),
+                PylintRunner(),
+                UnittestRunner(),
+            ]
+        )
+    )
+
+
+if __name__ == '__main__':
+    main()
+
+```

quickpub-0.8.0/quickpub.egg-info/SOURCES.txt

@@ -0,0 +1,34 @@
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+setup.py
+quickpub/__init__.py
+quickpub/__main__.py
+quickpub/classifiers.py
+quickpub/custom_types.py
+quickpub/enforcers.py
+quickpub/files.py
+quickpub/functions.py
+quickpub/proxy.py
+quickpub/py.typed
+quickpub/validators.py
+quickpub.egg-info/PKG-INFO
+quickpub.egg-info/SOURCES.txt
+quickpub.egg-info/dependency_links.txt
+quickpub.egg-info/requires.txt
+quickpub.egg-info/top_level.txt
+quickpub/runnables/__init__.py
+quickpub/runnables/common_check.py
+quickpub/runnables/configurable.py
+quickpub/runnables/has_optional_executable.py
+quickpub/runnables/runnable.py
+quickpub/runnables/implementations/__init__.py
+quickpub/runnables/implementations/mypy.py
+quickpub/runnables/implementations/pylint.py
+quickpub/runnables/implementations/pytest.py
+quickpub/runnables/implementations/unittest.py
+quickpub/structures/__init__.py
+quickpub/structures/additional_configuration.py
+quickpub/structures/bound.py
+quickpub/structures/version.py

quickpub-0.5.0/README.md

@@ -1 +0,0 @@
-# quickpub

quickpub-0.5.0/quickpub/__init__.py

@@ -1,6 +0,0 @@
-from .__main__ import publish
-from .classifiers import *
-from .files import *
-from .publish import *
-from .structures import *
-from .proxy import *

quickpub-0.5.0/quickpub/__main__.py

@@ -1,67 +0,0 @@
-from typing import Optional, Union
-from danielutils import get_python_version
-from .publish import build, upload, commit, metrics
-from .structures import Version, Config
-from .files import create_toml, create_setup
-from .classifiers import *
-
-
-def publish(
-        *,
-        name: str,
-        version: Optional[Union[Version, str]] = None,
-        author: str,
-        author_email: str,
-        description: str,
-        homepage: str,
-
-        min_python: Optional[Union[Version, str]] = None,
-
-        keywords: Optional[list[str]] = None,
-        dependencies: Optional[list[str]] = None,
-        config: Optional[Config] = None
-) -> None:
-    if version is None:
-        version: Version = None  # type: ignore
-    else:
-        version: Version = version if isinstance(version, Version) else Version.from_str(version)  # type: ignore
-
-    if min_python is None:
-        min_python = Version(*get_python_version())
-    if keywords is None:
-        keywords = []
-
-    if dependencies is None:
-        dependencies = []
-
-    create_setup()
-    create_toml(
-        name=name,
-        version=version,
-        author=author,
-        author_email=author_email,
-        description=description,
-        homepage=homepage,
-        keywords=keywords,
-        dependencies=dependencies,
-        classifiers=[
-            DevelopmentStatusClassifier.Alpha,
-            IntendedAudienceClassifier.Developers,
-            ProgrammingLanguageClassifier.Python3,
-            OperatingSystemClassifier.MicrosoftWindows
-        ],
-        min_python=min_python
-    )
-
-    build()
-    upload(
-        name=name,
-        version=version
-    )
-    commit(
-        version=version
-    )
-    metrics()
-
-# if __name__ == '__main__':
-#     publish()

quickpub-0.5.0/quickpub/proxy.py

@@ -1,11 +0,0 @@
-import danielutils
-
-
-# need it like this for the testing
-def cm(*args, **kwargs)->tuple[int,bytes,bytes]:
-    return danielutils.cm(*args, **kwargs)
-
-
-__all__ = [
-    "cm"
-]

quickpub-0.5.0/quickpub/structures.py

@@ -1,28 +0,0 @@
-from dataclasses import dataclass
-
-
-@dataclass
-class Version:
-    @staticmethod
-    def from_str(version_str: str) -> "Version":
-        return Version(*list(map(int, version_str.split("."))))
-
-    major: int = 0
-    minor: int = 0
-    patch: int = 0
-
-    def __str__(self) -> str:
-        return f"{self.major}.{self.minor}.{self.patch}"
-
-
-@dataclass
-class Config:
-    pylint: bool = False
-    mypy: bool = False
-
-
-
-__all__ = [
-    "Version",
-    "Config",
-]

quickpub-0.5.0/quickpub.egg-info/SOURCES.txt

@@ -1,15 +0,0 @@
-README.md
-pyproject.toml
-setup.py
-quickpub/__init__.py
-quickpub/__main__.py
-quickpub/classifiers.py
-quickpub/files.py
-quickpub/proxy.py
-quickpub/publish.py
-quickpub/structures.py
-quickpub.egg-info/PKG-INFO
-quickpub.egg-info/SOURCES.txt
-quickpub.egg-info/dependency_links.txt
-quickpub.egg-info/requires.txt
-quickpub.egg-info/top_level.txt