quickpub 3.0.1__tar.gz → 3.0.5__tar.gz

{quickpub-3.0.1/quickpub.egg-info → quickpub-3.0.5}/PKG-INFO

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

{quickpub-3.0.1 → quickpub-3.0.5}/pyproject.toml

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

{quickpub-3.0.1 → quickpub-3.0.5}/quickpub/__init__.py

@@ -2,4 +2,5 @@ from .structures import *
 from .strategies import *
 from .enforcers import ExitEarlyError
 from .qa import SupportsProgress
+from .logging_ import set_log_level
 from .__main__ import publish

{quickpub-3.0.1 → quickpub-3.0.5}/quickpub/__main__.py

@@ -1,5 +1,5 @@
 import asyncio
-from typing import Optional, Union, List, Any, Callable
+from typing import Optional, Union, List, Any
 
 import fire
 from danielutils import warning, error
@@ -13,7 +13,9 @@ 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(
         *,
@@ -37,7 +39,6 @@ def publish(
         keywords: Optional[List[str]] = None,
         explicit_src_folder_path: Optional[str] = None,
         # ========== QA Parameters ==========
-        log: Optional[Callable[[Any], None]] = None,
         pbar: Optional[SupportsProgress] = None,  # tqdm
 
         demo: bool = False,
@@ -87,7 +88,6 @@ def publish(
             name,
             explicit_src_folder_path,
             validated_dependencies,
-            log,
             pbar
         ))
         if not res:

{quickpub-3.0.1 → quickpub-3.0.5}/quickpub/classifiers.py

@@ -1,6 +1,8 @@
-from abc import ABC, abstractmethod
+import logging
 from enum import Enum
 
+logger = logging.getLogger(__name__)
+
 
 class Classifier(Enum):
     """
@@ -36,7 +38,9 @@ class Classifier(Enum):
     def __str__(self) -> str:
         name = Classifier._split_name(self.__class__.__qualname__)
         value = self._str()
-        return f"{name} :: {value}"
+        result = f"{name} :: {value}"
+        logger.debug("Classifier string representation: %s", result)
+        return result
 
 
 class DevelopmentStatusClassifier(Classifier):

quickpub-3.0.5/quickpub/enforcers.py

@@ -0,0 +1,39 @@
+import logging
+from typing import Union, Callable
+
+from danielutils import error
+
+logger = logging.getLogger(__name__)
+
+
+class ExitEarlyError(Exception):
+    """Custom exception raised when early exit conditions are met."""
+
+
+def exit_if(
+        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()):
+        logger.error("Exit condition met: %s", msg)
+        if verbose:
+            err_func(msg)
+        raise ExitEarlyError(msg)
+
+
+__all__ = [
+    "exit_if",
+    "ExitEarlyError",
+]

{quickpub-3.0.1 → quickpub-3.0.5}/quickpub/files.py

@@ -1,9 +1,12 @@
+import logging
 from typing import List
 from danielutils import get_files
 
 from .classifiers import Classifier
 from .structures import Version, Dependency
 
+logger = logging.getLogger(__name__)
+
 
 def create_toml(
         *,
@@ -21,6 +24,24 @@ def create_toml(
         dependencies: List[Dependency],
         classifiers: List[Classifier]
 ) -> 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
+    :param license_file_path: Path to LICENSE file
+    :param version: Package version
+    :param author: Author name
+    :param author_email: Author email
+    :param description: Package description
+    :param homepage: Package homepage URL
+    :param keywords: List of package keywords
+    :param min_python: Minimum Python version required
+    :param dependencies: List of package dependencies
+    :param classifiers: List of package 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"
@@ -29,6 +50,7 @@ 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")
             break
 
     s = f"""[build-system]
@@ -59,16 +81,27 @@ packages = ["{name}"]
 """
     with open("pyproject.toml", "w", encoding="utf8") as f:
         f.write(s)
+    logger.info("Successfully created pyproject.toml")
 
 
 def create_setup() -> None:
+    """Create a basic setup.py file for the package."""
+    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:
+    """
+    Create a MANIFEST.in file for the package.
+    
+    :param name: Package name
+    """
+    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")
 
 
 __all__ = [

quickpub-3.0.5/quickpub/functions.py

@@ -0,0 +1,125 @@
+import logging
+from danielutils import info
+
+from .enforcers import exit_if
+from .structures import Version
+import quickpub.proxy
+
+logger = logging.getLogger(__name__)
+
+
+def build(
+        *,
+        verbose: bool = True
+) -> None:
+    """
+    Build the package distribution.
+    
+    :param verbose: Whether to display verbose output
+    """
+    logger.info("Starting build process")
+    if verbose:
+        info("Creating new distribution...")
+        logger.info("Creating new distribution...")
+
+    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.info("Build completed successfully")
+
+
+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
+    """
+    logger.info("Starting upload process for package '%s' version '%s'", name, version)
+    if verbose:
+        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")
+
+    if ret != 0:
+        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"
+        )
+
+    logger.info("Successfully uploaded package '%s' version '%s'", name, version)
+
+
+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
+    """
+    logger.info("Starting Git commit process for version '%s'", version)
+
+    if verbose:
+        info("Git")
+        info("\tStaging")
+        logger.info("Staging files for Git 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")
+        )
+
+    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}\"")
+    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")
+        )
+
+    if verbose:
+        info("\tPushing")
+        logger.info("Pushing changes to remote repository")
+
+    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.info("Successfully committed and pushed version '%s'", version)
+
+
+__all__ = [
+    "build",
+    "upload",
+    "commit",
+]

quickpub-3.0.5/quickpub/logging_.py

@@ -0,0 +1,105 @@
+import logging
+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')
+
+class TqdmLoggingHandler(logging.Handler):
+    """
+    Custom logging handler that uses tqdm.write to avoid conflicts with progress bars.
+    """
+
+    def __init__(self, level: int = logging.NOTSET):
+        super().__init__(level)
+        self._tqdm = None
+
+    def emit(self, record):
+        try:
+            import tqdm
+            msg = self.format(record)
+            tqdm.tqdm.write(msg, file=sys.stdout)
+        except ImportError:
+            # Fallback if tqdm becomes unavailable
+            print(self.format(record), file=sys.stdout)
+        except Exception:
+            self.handleError(record)
+
+def setup_logging(level: int = None):
+    """
+    Set up logging with appropriate handler based on tqdm availability.
+
+    If tqdm is installed, uses tqdm.write for output to avoid conflicts with progress bars.
+    If tqdm is not installed, uses a standard StreamHandler to stdout.
+
+    Args:
+        level: Logging level (default: uses the global _LOG_LEVEL constant)
+
+    Returns:
+        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)
+
+    # Clear any existing handlers
+    logger.handlers.clear()
+
+    # Common formatter for both handlers
+    formatter = logging.Formatter(
+        '%(asctime)s - %(name)s - %(levelname)s - %(filename)s:%(lineno)d - %(message)s'
+    )
+
+    try:
+        import tqdm
+
+        # Use tqdm.write if tqdm is available
+        handler = TqdmLoggingHandler()
+    except ImportError:
+        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"
+]

quickpub-3.0.5/quickpub/proxy.py

@@ -0,0 +1,56 @@
+import logging
+import os
+from typing import Tuple
+import requests
+import danielutils
+
+logger = logging.getLogger(__name__)
+
+
+# need it like this for the testing
+def cm(*args, **kwargs) -> Tuple[int, bytes, bytes]:
+    """
+    Execute a command and return the result.
+    
+    :param args: Command arguments
+    :param kwargs: Additional keyword arguments
+    :return: Tuple of (return_code, stdout, stderr)
+    """
+    logger.debug("Executing command: %s", ' '.join(args))
+    result = danielutils.cm(*args, **kwargs)
+    logger.debug("Command completed with return code: %d", result[0])
+    return result
+
+
+def os_system(command) -> int:
+    """
+    Execute a system command.
+    
+    :param command: Command to execute
+    :return: Return code of the command
+    """
+    logger.debug("Executing system command: %s", command)
+    result = os.system(command)
+    logger.debug("System command completed with return code: %d", result)
+    return result
+
+
+def get(*args, **kwargs) -> requests.models.Response:
+    """
+    Make an HTTP GET request.
+    
+    :param args: Request arguments
+    :param kwargs: Additional keyword arguments
+    :return: Response object
+    """
+    logger.debug("Making HTTP GET request to: %s", args[0] if args else 'URL not provided')
+    response = requests.get(*args, **kwargs)
+    logger.debug("HTTP GET request completed with status code: %d", response.status_code)
+    return response
+
+
+__all__ = [
+    "cm",
+    'os_system',
+    "get"
+]