quickpub 3.0.6__tar.gz → 3.1.0__tar.gz

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

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: quickpub
-Version: 3.0.6
-Summary: A python package to quickly configure and publish a new package
+Version: 3.1.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
         
@@ -38,7 +38,7 @@ Requires-Dist: requests
 Requires-Dist: fire
 Dynamic: license-file
 
-# QuickPub v3.0.0
+# QuickPub v3.0.61
 
 [![Python 3.8+](https://img.shields.io/badge/python-3.8+-blue.svg)](https://www.python.org/downloads/)
 [![License](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)

{quickpub-3.0.6 → quickpub-3.1.0}/README.md

@@ -1,4 +1,4 @@
-# QuickPub v3.0.0
+# QuickPub v3.0.61
 
 [![Python 3.8+](https://img.shields.io/badge/python-3.8+-blue.svg)](https://www.python.org/downloads/)
 [![License](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)

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

@@ -4,14 +4,14 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "quickpub"
-version = "3.0.6"
+version = "3.1.0"
 authors = [
     { name = "danielnachumdev", email = "danielnachumdev@gmail.com" },
 ]
 dependencies = ['danielutils>=1.0.0', 'requests', 'fire']
 keywords = []
 license = { "file" = "./LICENSE" }
-description = "A python package to quickly configure and publish a new package"
+description = "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"
 readme = {file = "./README.md", content-type = "text/markdown"}
 requires-python = ">=3.8.0"
 classifiers = [
@@ -20,9 +20,12 @@ classifiers = [
 	"Programming Language :: Python :: 3",
 	"Operating System :: Microsoft :: Windows"
 ]
+[project.scripts]
+    quickpub = "quickpub.__main__:main"
 
 [tool.setuptools]
 packages = ["quickpub"]
+
 [tool.setuptools.package-data]
 "quickpub" = ["py.typed"]
 

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

@@ -3,4 +3,4 @@ from .strategies import *
 from .enforcers import ExitEarlyError
 from .qa import SupportsProgress
 from .logging_ import set_log_level
-from .__main__ import publish
+from .__main__ import publish, main

quickpub-3.1.0/quickpub/__main__.py

@@ -0,0 +1,156 @@
+import asyncio
+from typing import Optional, Union, List, Any, Dict, Callable
+
+import fire
+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
+from .classifiers import *
+from .qa import qa, SupportsProgress
+from .logging_ import setup_logging
+
+setup_logging()
+
+
+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,
+    # ========== QA Parameters ==========
+    pbar: Optional[SupportsProgress] = None,  # tqdm
+    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 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".
+    :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 scripts: Optional dictionary mapping script names to functions for [project.scripts] section. Each entry will create an executable entry point.
+    :param log: A function to receive log statements about the process and print them (or do something else idk)
+    :param pbar: and object that can be notified about an update of progress like a tqdm progress bar.
+    :param demo: Whether to perform checks without making any changes. Defaults to False.
+    :param config: Reserved for future use. Defaults to None.
+
+    Returns:
+        None
+    """
+    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"
+        )
+    min_python = validate_python_version(min_python)  # type:ignore
+    keywords = validate_keywords(keywords)
+    validated_dependencies: List[Dependency] = validate_dependencies(dependencies)
+    for enforcer in enforcers or []:
+        enforcer.enforce(name=name, version=version, demo=demo)
+    try:
+        res = 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 res:
+            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
+
+    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)
+    if not demo:
+        for schema in build_schemas:
+            schema.build()
+        for target in upload_targets:
+            target.upload(name=name, version=version)
+
+
+def main() -> None:
+    fire.Fire(publish)
+
+
+if __name__ == "__main__":
+    main()
+
+__all__ = ["main", "publish"]

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

@@ -15,7 +15,7 @@ class Classifier(Enum):
     @staticmethod
     def _split_name(name: str) -> str:
         words = []
-        current_word = ''
+        current_word = ""
 
         for char in name:
             # Check if the character is uppercase
@@ -47,6 +47,7 @@ class DevelopmentStatusClassifier(Classifier):
     """
     An enum class for specifying the development state of the package
     """
+
     # https://pypi.org/classifiers/
     Planning = 1
     PreAlpha = 2
@@ -65,6 +66,7 @@ class IntendedAudienceClassifier(Classifier):
     """
     An enum class for specifying the intended audience
     """
+
     CustomerService = "CustomerService"
     Developers = "Developers"
 
@@ -73,6 +75,7 @@ class ProgrammingLanguageClassifier(Classifier):
     """
     An enum class for specifying the target language level
     """
+
     Python3 = "Python :: 3"
 
 
@@ -80,6 +83,7 @@ class OperatingSystemClassifier(Classifier):
     """
     An enum class for specifying the target operating system
     """
+
     MicrosoftWindows = "Microsoft :: Windows"
 
 
@@ -88,5 +92,5 @@ __all__ = [
     "DevelopmentStatusClassifier",
     "IntendedAudienceClassifier",
     "ProgrammingLanguageClassifier",
-    "OperatingSystemClassifier"
+    "OperatingSystemClassifier",
 ]

{quickpub-3.0.6 → quickpub-3.1.0}/quickpub/enforcers.py

@@ -11,22 +11,24 @@ class ExitEarlyError(Exception):
 
 
 def exit_if(
-        predicate: Union[bool, Callable[[], bool]],
-        msg: str,
-        *,
-        verbose: bool = True,
-        err_func: Callable[[str], None] = error
+    predicate: Union[bool, Callable[[], bool]],
+    msg: str,
+    *,
+    verbose: bool = True,
+    err_func: Callable[[str], None] = error,
 ) -> None:
     """
     Exit the program if the given predicate is true.
-    
+
     :param predicate: Boolean value or callable that returns a boolean
     :param msg: Error message to display
     :param verbose: Whether to display the error message
     :param err_func: Function to call for error display
     :raises ExitEarlyError: When the predicate condition is met
     """
-    if (isinstance(predicate, bool) and predicate) or (callable(predicate) and predicate()):
+    if (isinstance(predicate, bool) and predicate) or (
+        callable(predicate) and predicate()
+    ):
         logger.error("Exit condition met: %s", msg)
         if verbose:
             err_func(msg)

{quickpub-3.0.6 → quickpub-3.1.0}/quickpub/files.py

@@ -1,5 +1,5 @@
 import logging
-from typing import List
+from typing import List, Optional, Dict, Callable
 from danielutils import get_files
 
 from .classifiers import Classifier
@@ -9,24 +9,25 @@ logger = logging.getLogger(__name__)
 
 
 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]
+    *,
+    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:
     """
     Create a pyproject.toml file for the package.
-    
+
     :param name: Package name
     :param src_folder_path: Path to source folder
     :param readme_file_path: Path to README file
@@ -40,9 +41,11 @@ def create_toml(
     :param min_python: Minimum Python version required
     :param dependencies: List of package dependencies
     :param classifiers: List of package classifiers
+    :param scripts: Optional dictionary mapping script names to functions for [project.scripts] section
     """
-    logger.info("Creating pyproject.toml for package '%s' version '%s'", name, version)
-    classifiers_string = ",\n\t".join([f"\"{str(c)}\"" for c in classifiers])
+    logger.info(
+        "Creating pyproject.toml for package '%s' version '%s'", name, version)
+    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 = ""
@@ -50,9 +53,26 @@ def create_toml(
         if file == "py.typed":
             py_typed = f"""[tool.setuptools.package-data]
 "{name}" = ["py.typed"]"""
-            logger.debug("Found py.typed file, adding package-data configuration")
+            logger.debug(
+                "Found py.typed file, adding package-data configuration")
             break
 
+    scripts_section = ""
+    if scripts:
+        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 is __main__, prefix it with package name
+            if module == "__main__":
+                module = f"{name}.__main__"
+            entry_point = f"{module}:{func_name}"
+            scripts_entries.append(f'    {script_name} = "{entry_point}"')
+        scripts_section = "\n[project.scripts]\n" + \
+            "\n".join(scripts_entries) + "\n"
+
     s = f"""[build-system]
 requires = ["setuptools>=61.0"]
 build-backend = "setuptools.build_meta"
@@ -69,10 +89,10 @@ license = {{ "file" = "{license_file_path}" }}
 description = "{description}"
 readme = {{file = "{readme_file_path}", content-type = "text/markdown"}}
 requires-python = ">={min_python}"
-classifiers = [{classifiers_string}]
-
+classifiers = [{classifiers_string}]{scripts_section}
 [tool.setuptools]
 packages = ["{name}"]
+
 {py_typed}
 
 [project.urls]
@@ -95,7 +115,7 @@ def create_setup() -> None:
 def create_manifest(*, name: str) -> None:
     """
     Create a MANIFEST.in file for the package.
-    
+
     :param name: Package name
     """
     logger.info("Creating MANIFEST.in for package '%s'", name)
@@ -104,7 +124,4 @@ def create_manifest(*, name: str) -> None:
     logger.info("Successfully created MANIFEST.in")
 
 
-__all__ = [
-    "create_setup",
-    "create_toml"
-]
+__all__ = ["create_setup", "create_toml"]

{quickpub-3.0.6 → quickpub-3.1.0}/quickpub/functions.py

@@ -8,13 +8,10 @@ import quickpub.proxy
 logger = logging.getLogger(__name__)
 
 
-def build(
-        *,
-        verbose: bool = True
-) -> None:
+def build(*, verbose: bool = True) -> None:
     """
     Build the package distribution.
-    
+
     :param verbose: Whether to display verbose output
     """
     logger.info("Starting build process")
@@ -25,24 +22,18 @@ def build(
     ret, stdout, stderr = quickpub.proxy.cm("python", "setup.py", "sdist")
 
     if ret != 0:
-        logger.error("Build failed with return code %d: %s", ret, stderr.decode(encoding='utf8'))
-        exit_if(
-            ret != 0,
-            stderr.decode(encoding="utf8")
+        logger.error(
+            "Build failed with return code %d: %s", ret, stderr.decode(encoding="utf8")
         )
+        exit_if(ret != 0, stderr.decode(encoding="utf8"))
 
     logger.info("Build completed successfully")
 
 
-def upload(
-        *,
-        name: str,
-        version: Version,
-        verbose: bool = True
-) -> None:
+def upload(*, name: str, version: Version, verbose: bool = True) -> None:
     """
     Upload the package to PyPI.
-    
+
     :param name: Package name
     :param version: Package version
     :param verbose: Whether to display verbose output
@@ -52,27 +43,26 @@ def upload(
         info("Uploading")
         logger.info("Uploading package to PyPI")
 
-    ret, stdout, stderr = quickpub.proxy.cm("twine", "upload", "--config-file", ".pypirc",
-                                            f"dist/{name}-{version}.tar.gz")
+    ret, stdout, stderr = quickpub.proxy.cm(
+        "twine", "upload", "--config-file", ".pypirc", f"dist/{name}-{version}.tar.gz"
+    )
 
     if ret != 0:
-        logger.error("Upload failed with return code %d: %s", ret, stderr.decode(encoding='utf8'))
+        logger.error(
+            "Upload failed with return code %d: %s", ret, stderr.decode(encoding="utf8")
+        )
         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"
+            f"Failed uploading the package to pypi. Try running the following command manually:\n\ttwine upload --config-file .pypirc dist/{name}-{version}.tar.gz",
         )
 
     logger.info("Successfully uploaded package '%s' version '%s'", name, version)
 
 
-def commit(
-        *,
-        version: Version,
-        verbose: bool = True
-) -> None:
+def commit(*, version: Version, verbose: bool = True) -> None:
     """
     Commit and push changes to Git repository.
-    
+
     :param version: Package version
     :param verbose: Whether to display verbose output
     """
@@ -85,23 +75,27 @@ def commit(
 
     ret, stdout, stderr = quickpub.proxy.cm("git add .")
     if ret != 0:
-        logger.error("Git add failed with return code %d: %s", ret, stderr.decode(encoding='utf8'))
-        exit_if(
-            ret != 0,
-            stderr.decode(encoding="utf8")
+        logger.error(
+            "Git add failed with return code %d: %s",
+            ret,
+            stderr.decode(encoding="utf8"),
         )
+        exit_if(ret != 0, stderr.decode(encoding="utf8"))
 
     if verbose:
         info("\tCommitting")
         logger.info("Committing changes with message 'updated to version %s'", version)
 
-    ret, stdout, stderr = quickpub.proxy.cm(f"git commit -m \"updated to version {version}\"")
+    ret, stdout, stderr = quickpub.proxy.cm(
+        f'git commit -m "updated to version {version}"'
+    )
     if ret != 0:
-        logger.error("Git commit failed with return code %d: %s", ret, stderr.decode(encoding='utf8'))
-        exit_if(
-            ret != 0,
-            stderr.decode(encoding="utf8")
+        logger.error(
+            "Git commit failed with return code %d: %s",
+            ret,
+            stderr.decode(encoding="utf8"),
         )
+        exit_if(ret != 0, stderr.decode(encoding="utf8"))
 
     if verbose:
         info("\tPushing")
@@ -109,11 +103,12 @@ def commit(
 
     ret, stdout, stderr = quickpub.proxy.cm("git push")
     if ret != 0:
-        logger.error("Git push failed with return code %d: %s", ret, stderr.decode(encoding='utf8'))
-        exit_if(
-            ret != 0,
-            stderr.decode(encoding="utf8")
+        logger.error(
+            "Git push failed with return code %d: %s",
+            ret,
+            stderr.decode(encoding="utf8"),
         )
+        exit_if(ret != 0, stderr.decode(encoding="utf8"))
 
     logger.info("Successfully committed and pushed version '%s'", version)
 

{quickpub-3.0.6 → quickpub-3.1.0}/quickpub/logging_.py

@@ -4,13 +4,15 @@ import sys
 # Global log level that can be modified by users
 _LOG_LEVEL = logging.INFO
 
+
 class QuickpubLogFilter(logging.Filter):
     """
     Filter that only allows logs from the quickpub package.
     """
-    
+
     def filter(self, record):
-        return record.name.startswith('quickpub')
+        return record.name.startswith("quickpub")
+
 
 class TqdmLoggingHandler(logging.Handler):
     """
@@ -24,6 +26,7 @@ class TqdmLoggingHandler(logging.Handler):
     def emit(self, record):
         try:
             import tqdm
+
             msg = self.format(record)
             tqdm.tqdm.write(msg, file=sys.stdout)
         except ImportError:
@@ -32,6 +35,7 @@ class TqdmLoggingHandler(logging.Handler):
         except Exception:
             self.handleError(record)
 
+
 def setup_logging(level: int = None):
     """
     Set up logging with appropriate handler based on tqdm availability.
@@ -46,11 +50,11 @@ def setup_logging(level: int = None):
         Configured logger instance
     """
     global _LOG_LEVEL
-    
+
     # Use provided level or fall back to global constant
     if level is not None:
         _LOG_LEVEL = level
-    
+
     logger = logging.getLogger()
     logger.setLevel(_LOG_LEVEL)
 
@@ -58,8 +62,9 @@ def setup_logging(level: int = None):
     logger.handlers.clear()
 
     # Common formatter for both handlers
+    # Example output: 2024-01-15 10:30:45,123 - INFO - [quickpub.some_module - some_module.py:42] - This is a log message
     formatter = logging.Formatter(
-        '%(asctime)s - %(name)s - %(levelname)s - %(filename)s:%(lineno)d - %(message)s'
+        "%(asctime)s - %(levelname)s - [%(name)s - %(filename)s:%(lineno)d] - %(message)s"
     )
 
     try:
@@ -71,35 +76,33 @@ def setup_logging(level: int = None):
         handler = logging.StreamHandler(sys.stdout)
     handler.setLevel(_LOG_LEVEL)
     handler.setFormatter(formatter)
-    
+
     # Add filter to only allow quickpub logs
     handler.addFilter(QuickpubLogFilter())
-    
+
     logger.addHandler(handler)
 
+
 def set_log_level(level: int):
     """
     Set the logging level for the root logger and all its handlers.
-    
+
     This function allows end users to dynamically change the log level
     after logging has been set up. It also updates the global _LOG_LEVEL
     constant so that future calls to setup_logging() will use this level.
-    
+
     Args:
         level: Logging level (e.g., logging.DEBUG, logging.INFO, logging.WARNING, logging.ERROR)
     """
     global _LOG_LEVEL
     _LOG_LEVEL = level
-    
+
     logger = logging.getLogger()
     logger.setLevel(level)
-    
+
     # Update all handlers to use the new level
     for handler in logger.handlers:
         handler.setLevel(level)
 
-__all__ = [
-    "setup_logging",
-    "set_log_level",
-    "QuickpubLogFilter"
-]
+
+__all__ = ["setup_logging", "set_log_level", "QuickpubLogFilter"]