quickpub 3.1.0__tar.gz → 4.0.0__tar.gz

{quickpub-3.1.0/quickpub.egg-info → quickpub-4.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quickpub
-Version: 3.1.0
+Version: 4.0.0
 Summary: A local CI/CD simulation tool that runs quality checks, tests, and validations locally before publishing Python packages, ensuring higher build pass rates and faster feedback loops
 Author-email: danielnachumdev <danielnachumdev@gmail.com>
 License: MIT License

{quickpub-3.1.0 → quickpub-4.0.0}/pyproject.toml

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

{quickpub-3.1.0 → quickpub-4.0.0}/quickpub/__init__.py

@@ -4,3 +4,5 @@ from .enforcers import ExitEarlyError
 from .qa import SupportsProgress
 from .logging_ import set_log_level
 from .__main__ import publish, main
+
+__version__ = "4.0.0"

quickpub-4.0.0/quickpub/__main__.py

@@ -0,0 +1,243 @@
+import asyncio
+import logging
+import time
+from typing import Optional, Union, List, Any, Dict, Callable, Tuple
+
+import fire  # type: ignore[import-untyped]
+from danielutils import warning, error
+
+from quickpub import ExitEarlyError
+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, add_version_to_init
+from .classifiers import *
+from .qa import qa, SupportsProgress
+from .logging_ import setup_logging
+
+setup_logging()
+logger = logging.getLogger(__name__)
+
+
+def _validate_publish_inputs(
+    name: str,
+    version: Optional[Union[Version, str]],
+    explicit_src_folder_path: Optional[str],
+    min_python: Optional[Union[Version, str]],
+    keywords: Optional[List[str]],
+    dependencies: Optional[List[Union[str, Dependency]]],
+) -> Tuple[Version, str, Version, List[str], List[Dependency]]:
+    validated_version = validate_version(version)
+    validated_src_path = validate_source(name, explicit_src_folder_path)
+    if validated_src_path != f"./{name}":
+        warning(
+            "The source folder's name is different from the package's name. this may not be currently supported correctly"
+        )
+    converted_min_python: Optional[Version] = None
+    if min_python is not None:
+        converted_min_python = (
+            min_python
+            if isinstance(min_python, Version)
+            else Version.from_str(min_python)
+        )
+    validated_min_python = validate_python_version(converted_min_python)
+    validated_keywords = validate_keywords(keywords)
+    validated_deps = validate_dependencies(dependencies)
+    return (
+        validated_version,
+        validated_src_path,
+        validated_min_python,
+        validated_keywords,
+        validated_deps,
+    )
+
+
+def _run_constraint_enforcers(
+    enforcers: Optional[List[ConstraintEnforcer]],
+    name: str,
+    version: Version,
+    demo: bool,
+) -> None:
+    for enforcer in enforcers or []:
+        enforcer.enforce(name=name, version=version, demo=demo)
+
+
+def _run_quality_assurance(
+    python_interpreter_provider: PythonProvider,
+    global_quality_assurance_runners: Optional[List[QualityAssuranceRunner]],
+    name: str,
+    explicit_src_folder_path: str,
+    validated_dependencies: List[Dependency],
+    pbar: Optional[SupportsProgress],
+) -> None:
+    try:
+        result = asyncio.get_event_loop().run_until_complete(
+            qa(
+                python_interpreter_provider,
+                global_quality_assurance_runners or [],
+                name,
+                explicit_src_folder_path,
+                validated_dependencies,
+                pbar,
+            )
+        )
+        if not result:
+            error(
+                f"quickpub.publish exited early as '{name}' "
+                "did not pass quality assurance step, see above "
+                "logs to pass this step."
+            )
+            raise ExitEarlyError("QA step Failed")
+    except ExitEarlyError as e:
+        raise e
+    except Exception as e:
+        raise RuntimeError("Quality assurance stage has failed", e) from e
+
+
+def _create_package_files(
+    name: str,
+    explicit_src_folder_path: str,
+    readme_file_path: str,
+    license_file_path: str,
+    version: Version,
+    author: str,
+    author_email: str,
+    description: str,
+    homepage: str,
+    keywords: List[str],
+    validated_dependencies: List[Dependency],
+    min_python: Version,
+    scripts: Optional[Dict[str, Callable]],
+) -> None:
+    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,
+        scripts=scripts,
+    )
+    create_manifest(name=name)
+    add_version_to_init(
+        name=name, src_folder_path=explicit_src_folder_path, version=version
+    )
+
+
+def _build_and_upload_packages(
+    build_schemas: List[BuildSchema],
+    upload_targets: List[UploadTarget],
+    name: str,
+    version: Version,
+    demo: bool,
+) -> None:
+    if not demo:
+        for schema in build_schemas:
+            schema.build()
+        for target in upload_targets:
+            target.upload(name=name, version=version)
+
+
+def publish(
+    *,
+    name: str,
+    author: str,
+    author_email: str,
+    description: str,
+    homepage: str,
+    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(),
+    readme_file_path: str = "./README.md",
+    license_file_path: str = "./LICENSE",
+    version: Optional[Union[Version, str]] = None,
+    min_python: Optional[Union[Version, str]] = None,
+    dependencies: Optional[List[Union[str, Dependency]]] = None,
+    keywords: Optional[List[str]] = None,
+    explicit_src_folder_path: Optional[str] = None,
+    scripts: Optional[Dict[str, Callable]] = None,
+    pbar: Optional[SupportsProgress] = None,
+    demo: bool = False,
+    config: Optional[Any] = None,
+) -> None:
+    start_time = time.perf_counter()
+    success = False
+    try:
+        (
+            validated_version,
+            validated_src_path,
+            validated_min_python,
+            validated_keywords,
+            validated_deps,
+        ) = _validate_publish_inputs(
+            name, version, explicit_src_folder_path, min_python, keywords, dependencies
+        )
+        _run_constraint_enforcers(enforcers, name, validated_version, demo)
+        _run_quality_assurance(
+            python_interpreter_provider,
+            global_quality_assurance_runners,
+            name,
+            validated_src_path,
+            validated_deps,
+            pbar,
+        )
+        _create_package_files(
+            name,
+            validated_src_path,
+            readme_file_path,
+            license_file_path,
+            validated_version,
+            author,
+            author_email,
+            description,
+            homepage,
+            validated_keywords,
+            validated_deps,
+            validated_min_python,
+            scripts,
+        )
+        _build_and_upload_packages(
+            build_schemas, upload_targets, name, validated_version, demo
+        )
+        success = True
+    finally:
+        elapsed = time.perf_counter() - start_time
+        logger.info("Publish finished in %.3fs (success=%s)", elapsed, success)
+
+
+def main() -> None:
+    fire.Fire(publish)
+
+
+if __name__ == "__main__":
+    main()
+
+__all__ = ["main", "publish"]

{quickpub-3.1.0 → quickpub-4.0.0}/quickpub/classifiers.py

@@ -1,96 +1,79 @@
-import logging
-from enum import Enum
-
-logger = logging.getLogger(__name__)
-
-
-class Classifier(Enum):
-    """
-    A base enum class for all classifiers.
-    """
-
-    def _str(self) -> str:
-        return str(self.value)
-
-    @staticmethod
-    def _split_name(name: str) -> str:
-        words = []
-        current_word = ""
-
-        for char in name:
-            # Check if the character is uppercase
-            if char.isupper():
-                # If current_word is not empty, add it to words list
-                if current_word:
-                    words.append(current_word)
-                # Start a new word with the uppercase character
-                current_word = char
-            else:
-                # Add lowercase character to current_word
-                current_word += char
-
-        # Add the last word to the list
-        if current_word:
-            words.append(current_word)
-
-        return " ".join(words[:-1])
-
-    def __str__(self) -> str:
-        name = Classifier._split_name(self.__class__.__qualname__)
-        value = self._str()
-        result = f"{name} :: {value}"
-        logger.debug("Classifier string representation: %s", result)
-        return result
-
-
-class DevelopmentStatusClassifier(Classifier):
-    """
-    An enum class for specifying the development state of the package
-    """
-
-    # https://pypi.org/classifiers/
-    Planning = 1
-    PreAlpha = 2
-    Alpha = 3
-    Beta = 4
-    Production = 5
-    Stable = 5
-    Mature = 6
-    Inactive = 7
-
-    def _str(self) -> str:
-        return f"{self.value} - {self.name}"
-
-
-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"
-
-
-__all__ = [
-    "Classifier",
-    "DevelopmentStatusClassifier",
-    "IntendedAudienceClassifier",
-    "ProgrammingLanguageClassifier",
-    "OperatingSystemClassifier",
-]
+import logging
+from enum import Enum
+
+logger = logging.getLogger(__name__)
+
+
+class Classifier(Enum):
+
+    def _str(self) -> str:
+        return str(self.value)
+
+    @staticmethod
+    def _split_name(name: str) -> str:
+        words = []
+        current_word = ""
+
+        for char in name:
+            if char.isupper():
+                if current_word:
+                    words.append(current_word)
+                current_word = char
+            else:
+                current_word += char
+
+        if current_word:
+            words.append(current_word)
+
+        return " ".join(words[:-1])
+
+    def __str__(self) -> str:
+        name = Classifier._split_name(self.__class__.__qualname__)
+        value = self._str()
+        result = f"{name} :: {value}"
+        logger.debug("Classifier string representation: %s", result)
+        return result
+
+
+class DevelopmentStatusClassifier(Classifier):
+    """Classifier for package development status. Use values like Alpha, Beta, Production, etc."""
+
+    Planning = 1
+    PreAlpha = 2
+    Alpha = 3
+    Beta = 4
+    Production = 5
+    Stable = 5
+    Mature = 6
+    Inactive = 7
+
+    def _str(self) -> str:
+        return f"{self.value} - {self.name}"
+
+
+class IntendedAudienceClassifier(Classifier):
+    """Classifier for intended audience of the package."""
+
+    CustomerService = "CustomerService"
+    Developers = "Developers"
+
+
+class ProgrammingLanguageClassifier(Classifier):
+    """Classifier for programming languages supported by the package."""
+
+    Python3 = "Python :: 3"
+
+
+class OperatingSystemClassifier(Classifier):
+    """Classifier for operating systems supported by the package."""
+
+    MicrosoftWindows = "Microsoft :: Windows"
+
+
+__all__ = [
+    "Classifier",
+    "DevelopmentStatusClassifier",
+    "IntendedAudienceClassifier",
+    "ProgrammingLanguageClassifier",
+    "OperatingSystemClassifier",
+]

quickpub-4.0.0/quickpub/enforcers.py

@@ -0,0 +1,26 @@
+import logging
+from typing import Union, Callable
+
+
+logger = logging.getLogger(__name__)
+
+
+class ExitEarlyError(Exception):
+    pass
+
+
+def exit_if(
+    predicate: Union[bool, Callable[[], bool]],
+    msg: str,
+) -> None:
+    if (isinstance(predicate, bool) and predicate) or (
+        callable(predicate) and predicate()
+    ):
+        logger.error("Exit condition met: %s", msg)
+        raise ExitEarlyError(msg)
+
+
+__all__ = [
+    "exit_if",
+    "ExitEarlyError",
+]

quickpub-4.0.0/quickpub/files.py

@@ -0,0 +1,196 @@
+import logging
+import re
+from pathlib import Path
+from typing import List, Optional, Dict, Callable
+from danielutils import get_files, file_exists
+
+from .classifiers import Classifier
+from .structures import Version, Dependency
+
+logger = logging.getLogger(__name__)
+
+
+def _format_classifiers_string(classifiers: List[Classifier]) -> str:
+    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"
+    return classifiers_string
+
+
+def _build_py_typed_section(name: str, src_folder_path: str) -> str:
+    for file in get_files(src_folder_path):
+        if file == "py.typed":
+            logger.debug("Found py.typed file, adding package-data configuration")
+            return f"""[tool.setuptools.package-data]
+"{name}" = ["py.typed"]"""
+    return ""
+
+
+def _build_scripts_section(name: str, scripts: Dict[str, Callable]) -> str:
+    logger.debug("Adding [project.scripts] section with %d entries", len(scripts))
+    scripts_entries = []
+    for script_name, func in scripts.items():
+        module = func.__module__
+        func_name = func.__name__
+        if module == "__main__":
+            module = f"{name}.__main__"
+        entry_point = f"{module}:{func_name}"
+        scripts_entries.append(f'    {script_name} = "{entry_point}"')
+    return "\n[project.scripts]\n" + "\n".join(scripts_entries) + "\n"
+
+
+def _build_toml_content(
+    name: str,
+    version: Version,
+    author: str,
+    author_email: str,
+    description: str,
+    readme_file_path: str,
+    license_file_path: str,
+    keywords: List[str],
+    min_python: Version,
+    dependencies: List[Dependency],
+    classifiers_string: str,
+    scripts_section: str,
+    py_typed: str,
+    homepage: str,
+) -> str:
+    normalized_readme_path = readme_file_path.replace("\\", "/")
+    normalized_license_path = license_file_path.replace("\\", "/")
+    return f"""[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "{name}"
+version = "{version}"
+authors = [
+    {{ name = "{author}", email = "{author_email}" }},
+]
+dependencies = {[str(dep) for dep in dependencies]}
+keywords = {keywords}
+license = {{ "file" = "{normalized_license_path}" }}
+description = "{description}"
+readme = {{file = "{normalized_readme_path}", content-type = "text/markdown"}}
+requires-python = ">={min_python}"
+classifiers = [{classifiers_string}]{scripts_section}
+[tool.setuptools]
+packages = ["{name}"]
+
+{py_typed}
+
+[project.urls]
+"Homepage" = "{homepage}"
+"Bug Tracker" = "{homepage}/issues"
+"""
+
+
+def create_toml(
+    *,
+    name: str,
+    src_folder_path: str,
+    readme_file_path: str,
+    license_file_path: str,
+    version: Version,
+    author: str,
+    author_email: str,
+    description: str,
+    homepage: str,
+    keywords: List[str],
+    min_python: Version,
+    dependencies: List[Dependency],
+    classifiers: List[Classifier],
+    scripts: Optional[Dict[str, Callable]] = None,
+) -> None:
+    logger.info("Creating pyproject.toml for package '%s' version '%s'", name, version)
+    classifiers_string = _format_classifiers_string(classifiers)
+    py_typed = _build_py_typed_section(name, src_folder_path)
+    scripts_section = ""
+    if scripts:
+        scripts_section = _build_scripts_section(name, scripts)
+    toml_content = _build_toml_content(
+        name,
+        version,
+        author,
+        author_email,
+        description,
+        readme_file_path,
+        license_file_path,
+        keywords,
+        min_python,
+        dependencies,
+        classifiers_string,
+        scripts_section,
+        py_typed,
+        homepage,
+    )
+    with open("pyproject.toml", "w", encoding="utf8") as f:
+        f.write(toml_content)
+    logger.info("Successfully created pyproject.toml")
+
+
+def create_setup() -> None:
+    logger.info("Creating setup.py file")
+    with open("./setup.py", "w", encoding="utf8") as f:
+        f.write("from setuptools import setup\n\nsetup()\n")
+    logger.info("Successfully created setup.py")
+
+
+def create_manifest(*, name: str) -> None:
+    logger.info("Creating MANIFEST.in for package '%s'", name)
+    with open("./MANIFEST.in", "w", encoding="utf8") as f:
+        f.write(f"recursive-include {name} *.py")
+    logger.info("Successfully created MANIFEST.in")
+
+
+def add_version_to_init(name: str, src_folder_path: str, version: Version) -> None:
+    init_file_path = Path(src_folder_path) / "__init__.py"
+
+    if not file_exists(str(init_file_path)):
+        logger.warning("__init__.py not found at '%s', creating it", init_file_path)
+        init_file_path.parent.mkdir(parents=True, exist_ok=True)
+        with open(init_file_path, "w", encoding="utf8") as f:
+            f.write(f'__version__ = "{version}"\n')
+        logger.info("Created __init__.py with __version__ = '%s'", version)
+        return
+
+    with open(init_file_path, "r", encoding="utf8") as f:
+        content = f.read()
+
+    version_line = f'__version__ = "{version}"'
+    version_pattern = r'__version__\s*=\s*["\'].*?["\']'
+
+    if re.search(version_pattern, content):
+        new_content = re.sub(version_pattern, version_line, content)
+        logger.info("Updated existing __version__ in __init__.py to '%s'", version)
+    else:
+        lines = content.splitlines()
+        if not lines:
+            new_content = f"{version_line}\n"
+        else:
+            import_end_index = 0
+            for i, line in enumerate(lines):
+                stripped = line.strip()
+                if not stripped or stripped.startswith("#"):
+                    continue
+                if stripped.startswith("from") or stripped.startswith("import"):
+                    import_end_index = i + 1
+                else:
+                    break
+
+            if import_end_index < len(lines):
+                lines.insert(import_end_index, version_line)
+            else:
+                lines.append(version_line)
+
+            new_content = "\n".join(lines)
+            if not content.endswith("\n"):
+                new_content += "\n"
+
+        logger.info("Added __version__ = '%s' to __init__.py", version)
+
+    with open(init_file_path, "w", encoding="utf8") as f:
+        f.write(new_content)
+
+
+__all__ = ["create_setup", "create_toml", "add_version_to_init"]