quickpub 3.0.5__tar.gz → 3.0.61__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quickpub
-Version: 3.0.5
+Version: 3.0.61
 Summary: A python package to quickly configure and publish a new package
 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.5 → quickpub-3.0.61}/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.5 → quickpub-3.0.61}/pyproject.toml

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

{quickpub-3.0.5 → quickpub-3.0.61}/quickpub/logging_.py

@@ -4,14 +4,16 @@ 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.
@@ -32,6 +34,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 +49,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 +61,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,33 +75,35 @@ 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",

{quickpub-3.0.5 → quickpub-3.0.61}/quickpub/strategies/implementations/quality_assurance_runners/unittest_qa_runner.py

@@ -1,108 +1,116 @@
-import logging
-import re
-import os
-from pathlib import Path
-from typing import Optional, List
-from danielutils import get_current_working_directory, set_current_working_directory, LayeredCommand, warning
-
-from ....enforcers import ExitEarlyError
-from ...quality_assurance_runner import QualityAssuranceRunner
-
-logger = logging.getLogger(__name__)
-
-
-def _removesuffix(string: str, suffix: str) -> str:
-    """Remove a suffix from a string.
-
-    Replace this with str.removesuffix() from stdlib when minimum Python
-    version is 3.9.
-    """
-    if suffix and string.endswith(suffix):
-        return string[: -len(suffix)]
-    return string
-
-
-class UnittestRunner(QualityAssuranceRunner):
-    """Quality assurance runner for unittest testing."""
-    NUM_TESTS_PATTERN: re.Pattern = re.compile(r"Ran (\d+) tests? in \d+\.\d+s")
-    NUM_FAILED_PATTERN: re.Pattern = re.compile(
-        r"FAILED \((?:failures=(\d+))?(?:, )?(?:errors=(\d+))?(?:, )?(?:skipped=(\d+))?\)|"
-        r"FAILED \((?:errors=(\d+))?(?:, )?(?:failures=(\d+))?(?:, )?(?:skipped=(\d+))?\)|"
-        r"FAILED \((?:skipped=(\d+))?(?:, )?(?:failures=(\d+))?(?:, )?(?:errors=(\d+))?\)")
-
-    def _install_dependencies(self, base: LayeredCommand) -> None:
-        return None
-
-    def _pre_command(self) -> None:
-        pass
-
-    def _post_command(self):
-        pass
-        # set_current_working_directory(self._cwd)
-
-    def __init__(self, target: Optional[str] = "./tests", bound: str = ">=0.8", no_tests_score: float = 0) -> None:
-        QualityAssuranceRunner.__init__(self, name="unittest", bound=bound, target=target)
-        self.no_tests_score = no_tests_score
-        logger.info("Initialized UnittestRunner with target='%s', bound='%s', no_tests_score=%s", target, bound,
-                    no_tests_score)
-
-    def _build_command(self, src: str, *args, use_system_interpreter: bool = False) -> str:
-        command: str = self.get_executable()
-        rel = _removesuffix(os.path.relpath(src, self.target), src.lstrip("./\\"))
-        command += f" discover -s {rel}"
-        normalized_target_path = Path(os.path.join(os.getcwd(), self.target)).resolve()
-        return f"cd {normalized_target_path} & {command} & cd {Path(os.getcwd()).resolve()}"  # This is for concurrency reasons
-
-    def _calculate_score(self, ret: int, lines: List[str], *, verbose: bool = False) -> float:
-        logger.info("Calculating unittest score from test results")
-
-        try:
-            num_tests_ran_line = lines[-3]
-            num_tests_failed_line = lines[-1]
-            num_tests = int(self.NUM_TESTS_PATTERN.match(num_tests_ran_line).group(1))
-            if num_tests == 0:
-                logger.info("No tests found, returning no_tests_score: %s", self.no_tests_score)
-                return self.no_tests_score
-
-            num_failed = 0
-            num_errors = 0
-            if num_tests_failed_line != "OK":
-                if num_tests_failed_line.startswith("FAILED"):
-                    m = self.NUM_FAILED_PATTERN.match(num_tests_failed_line)
-                    if m:
-                        # Handle different group positions based on the pattern that matched
-                        groups = m.groups()
-                        if groups[0] is not None:  # failures= first pattern
-                            num_failed = int(groups[0] or "0")
-                            num_errors = int(groups[1] or "0")
-                        elif groups[3] is not None:  # errors= first pattern
-                            num_failed = int(groups[4] or "0")
-                            num_errors = int(groups[3] or "0")
-                        elif groups[6] is not None:  # skipped= first pattern
-                            num_failed = int(groups[7] or "0")
-                            num_errors = int(groups[8] or "0")
-                        else:
-                            # Fallback to original logic if no groups match
-                            num_failed = int(m.group(1) or "0")
-                            num_errors = int(m.group(2) or "0")
-                    else:
-                        # If regex doesn't match, treat as malformed
-                        raise ValueError(f"Failed to parse FAILED line: {num_tests_failed_line}")
-                elif num_tests_failed_line.startswith("OK"):
-                    # 'OK (skipped=3)' could it also be other stuff?
-                    pass
-
-            score = 1 - ((num_failed + num_errors) / num_tests)
-            logger.info("Unittest score calculated: %.3f (tests: %d, failed: %d, errors: %d)", score, num_tests,
-                        num_failed, num_errors)
-            return score
-
-        except Exception as e:
-            logger.error("Failed to calculate unittest score: %s", e)
-            raise ExitEarlyError(f"Failed running Unittest, got exit code {ret}. "
-                                 f"try running manually using: {self._build_command('TARGET')}") from e
-
-
-__all__ = [
-    'UnittestRunner',
-]
+import logging
+import re
+import os
+from pathlib import Path
+from typing import Optional, List
+from danielutils import get_current_working_directory, set_current_working_directory, LayeredCommand, warning
+
+from ....enforcers import ExitEarlyError
+from ...quality_assurance_runner import QualityAssuranceRunner
+
+logger = logging.getLogger(__name__)
+
+
+def _removesuffix(string: str, suffix: str) -> str:
+    """Remove a suffix from a string.
+
+    Replace this with str.removesuffix() from stdlib when minimum Python
+    version is 3.9.
+    """
+    if suffix and string.endswith(suffix):
+        return string[: -len(suffix)]
+    return string
+
+
+class UnittestRunner(QualityAssuranceRunner):
+    """Quality assurance runner for unittest testing."""
+    NUM_TESTS_PATTERN: re.Pattern = re.compile(
+        r"Ran (\d+) tests? in \d+\.\d+s")
+    NUM_FAILED_PATTERN: re.Pattern = re.compile(
+        r"FAILED \((?:failures=(\d+))?(?:, )?(?:errors=(\d+))?(?:, )?(?:skipped=(\d+))?\)|"
+        r"FAILED \((?:errors=(\d+))?(?:, )?(?:failures=(\d+))?(?:, )?(?:skipped=(\d+))?\)|"
+        r"FAILED \((?:skipped=(\d+))?(?:, )?(?:failures=(\d+))?(?:, )?(?:errors=(\d+))?\)")
+
+    def _install_dependencies(self, base: LayeredCommand) -> None:
+        return None
+
+    def _pre_command(self) -> None:
+        pass
+
+    def _post_command(self):
+        pass
+        # set_current_working_directory(self._cwd)
+
+    def __init__(self, target: Optional[str] = "./tests", bound: str = ">=0.8", no_tests_score: float = 0) -> None:
+        QualityAssuranceRunner.__init__(
+            self, name="unittest", bound=bound, target=target)
+        self.no_tests_score = no_tests_score
+        logger.info("Initialized UnittestRunner with target='%s', bound='%s', no_tests_score=%s", target, bound,
+                    no_tests_score)
+
+    def _build_command(self, src: str, *args, use_system_interpreter: bool = False) -> str:
+        command: str = self.get_executable()
+        rel = _removesuffix(os.path.relpath(
+            src, self.target), src.lstrip("./\\"))
+        command += f" discover -s {rel}"
+        normalized_target_path = Path(
+            os.path.join(os.getcwd(), self.target)).resolve()
+        # This is for concurrency reasons
+        return f"cd {normalized_target_path} & {command} & cd {Path(os.getcwd()).resolve()}"
+
+    def _calculate_score(self, ret: int, lines: List[str], *, verbose: bool = False) -> float:
+        logger.debug("Calculating unittest score from test results")
+
+        try:
+            num_tests_ran_line = lines[-3]
+            num_tests_failed_line = lines[-1]
+            num_tests = int(self.NUM_TESTS_PATTERN.match(
+                num_tests_ran_line).group(1))
+            if num_tests == 0:
+                logger.debug(
+                    "No tests found, returning no_tests_score: %s", self.no_tests_score)
+                return self.no_tests_score
+
+            num_failed = 0
+            num_errors = 0
+            if num_tests_failed_line != "OK":
+                if num_tests_failed_line.startswith("FAILED"):
+                    m = self.NUM_FAILED_PATTERN.match(num_tests_failed_line)
+                    if m:
+                        # Handle different group positions based on the pattern that matched
+                        groups = m.groups()
+                        if groups[0] is not None:  # failures= first pattern
+                            num_failed = int(groups[0] or "0")
+                            num_errors = int(groups[1] or "0")
+                        elif groups[3] is not None:  # errors= first pattern
+                            num_failed = int(groups[4] or "0")
+                            num_errors = int(groups[3] or "0")
+                        elif groups[6] is not None:  # skipped= first pattern
+                            num_failed = int(groups[7] or "0")
+                            num_errors = int(groups[8] or "0")
+                        else:
+                            # Fallback to original logic if no groups match
+                            num_failed = int(m.group(1) or "0")
+                            num_errors = int(m.group(2) or "0")
+                    else:
+                        # If regex doesn't match, treat as malformed
+                        raise ValueError(
+                            f"Failed to parse FAILED line: {num_tests_failed_line}")
+                elif num_tests_failed_line.startswith("OK"):
+                    # 'OK (skipped=3)' could it also be other stuff?
+                    pass
+
+            score = 1 - ((num_failed + num_errors) / num_tests)
+            logger.debug("Unittest score calculated: %.3f (tests: %d, failed: %d, errors: %d)", score, num_tests,
+                         num_failed, num_errors)
+            return score
+
+        except Exception as e:
+            logger.error("Failed to calculate unittest score: %s", e)
+            raise ExitEarlyError(f"Failed running Unittest, got exit code {ret}. "
+                                 f"try running manually using: {self._build_command('TARGET')}") from e
+
+
+__all__ = [
+    'UnittestRunner',
+]

{quickpub-3.0.5 → quickpub-3.0.61}/quickpub/strategies/implementations/upload_targets/github_upload_target.py

@@ -7,6 +7,7 @@ logger = logging.getLogger(__name__)
 
 class GithubUploadTarget(UploadTarget):
     """Upload target implementation for GitHub releases."""
+
     def upload(self, version: str, **kwargs) -> None:  # type: ignore
         from quickpub.proxy import cm
         from quickpub.enforcers import exit_if
@@ -14,27 +15,32 @@ class GithubUploadTarget(UploadTarget):
         logger.info("Starting GitHub upload for version '%s'", version)
 
         if self.verbose:
-            logger.info("Staging files for Git commit")
+            logger.debug("Staging files for Git commit")
 
         ret, stdout, stderr = cm("git add .")
         if ret != 0:
-            logger.error("Git add failed with return code %d: %s", ret, 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 self.verbose:
-            logger.info("Committing changes with message 'updated to version %s'", version)
+            logger.debug(
+                "Committing changes with message 'updated to version %s'", version)
 
-        ret, stdout, stderr = cm(f"git commit -m \"updated to version {version}\"")
+        ret, stdout, stderr = 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'))
+            logger.error("Git commit failed with return code %d: %s",
+                         ret, stderr.decode(encoding='utf8'))
             exit_if(ret != 0, stderr.decode(encoding="utf8"))
 
         if self.verbose:
-            logger.info("Pushing changes to GitHub")
+            logger.debug("Pushing changes to GitHub")
 
         ret, stdout, stderr = cm("git push")
         if ret != 0:
-            logger.error("Git push failed with return code %d: %s", ret, 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 uploaded version '%s' to GitHub", version)

{quickpub-3.0.5 → quickpub-3.0.61}/quickpub/strategies/implementations/upload_targets/pypirc_upload_target.py

@@ -1,65 +1,75 @@
-import logging
-import re
-
-from danielutils import file_exists
-
-from ..constraint_enforcers import PypircEnforcer
-from ...upload_target import UploadTarget
-
-logger = logging.getLogger(__name__)
-
-
-class PypircUploadTarget(UploadTarget):
-    """Upload target implementation using .pypirc configuration."""
-    REGEX_PATTERN: re.Pattern = PypircEnforcer.PYPIRC_REGEX
-
-    def upload(self, name: str, version: str, **kwargs) -> None:  # type: ignore
-        from quickpub.proxy import cm
-        from quickpub.enforcers import exit_if
-
-        logger.info("Starting PyPI upload for package '%s' version '%s'", name, version)
-
-        self._validate_file_exists()
-        self._validate_file_contents()
-
-        if self.verbose:
-            logger.info("Uploading package to PyPI")
-
-        ret, stdout, stderr = cm("twine", "upload", "--config-file", ".pypirc",
-                                 f"dist/{name}-{version}.tar.gz")
-
-        if ret != 0:
-            logger.error("PyPI upload failed with return code %d: %s", ret, stderr)
-            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' to PyPI", name, version)
-
-    def _validate_file_exists(self) -> None:
-        logger.info("Validating .pypirc file exists at '%s'", self.pypirc_file_path)
-        if not file_exists(self.pypirc_file_path):
-            logger.error(".pypirc file not found at '%s'", self.pypirc_file_path)
-            raise RuntimeError(f"{self.__class__.__name__} can't find pypirc file at '{self.pypirc_file_path}'")
-        logger.info(".pypirc file found at '%s'", self.pypirc_file_path)
-
-    def _validate_file_contents(self) -> None:
-        logger.info("Validating .pypirc file contents at '%s'", self.pypirc_file_path)
-        with open(self.pypirc_file_path, "r", encoding="utf8") as f:
-            text = f.read()
-        if not self.REGEX_PATTERN.match(text):
-            logger.error(".pypirc file contents validation failed for '%s'", self.pypirc_file_path)
-            raise RuntimeError(
-                f"{self.__class__.__name__} checked the contents of '{self.pypirc_file_path}' and it failed to match the following regex: r\"{self.REGEX_PATTERN.pattern}\"")
-        logger.info(".pypirc file contents validation passed for '%s'", self.pypirc_file_path)
-
-    def __init__(self, pypirc_file_path: str = "./.pypirc", verbose: bool = False) -> None:
-        super().__init__(verbose)
-        self.pypirc_file_path = pypirc_file_path
-        logger.info("Initialized PypircUploadTarget with pypirc_file_path='%s', verbose=%s", pypirc_file_path, verbose)
-
-
-__all__ = [
-    "PypircUploadTarget"
-]
+import logging
+import re
+
+from danielutils import file_exists
+
+from ..constraint_enforcers import PypircEnforcer
+from ...upload_target import UploadTarget
+
+logger = logging.getLogger(__name__)
+
+
+class PypircUploadTarget(UploadTarget):
+    """Upload target implementation using .pypirc configuration."""
+    REGEX_PATTERN: re.Pattern = PypircEnforcer.PYPIRC_REGEX
+
+    def upload(self, name: str, version: str, **kwargs) -> None:  # type: ignore
+        from quickpub.proxy import cm
+        from quickpub.enforcers import exit_if
+
+        logger.info(
+            "Starting PyPI upload for package '%s' version '%s'", name, version)
+
+        self._validate_file_exists()
+        self._validate_file_contents()
+
+        if self.verbose:
+            logger.info("Uploading package to PyPI")
+
+        ret, stdout, stderr = cm("twine", "upload", "--config-file", ".pypirc",
+                                 f"dist/{name}-{version}.tar.gz")
+
+        if ret != 0:
+            logger.error(
+                "PyPI upload failed with return code %d: %s", ret, stderr)
+            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' to PyPI", name, version)
+
+    def _validate_file_exists(self) -> None:
+        logger.debug("Validating .pypirc file exists at '%s'",
+                     self.pypirc_file_path)
+        if not file_exists(self.pypirc_file_path):
+            logger.error(".pypirc file not found at '%s'",
+                         self.pypirc_file_path)
+            raise RuntimeError(
+                f"{self.__class__.__name__} can't find pypirc file at '{self.pypirc_file_path}'")
+        logger.debug(".pypirc file found at '%s'", self.pypirc_file_path)
+
+    def _validate_file_contents(self) -> None:
+        logger.debug("Validating .pypirc file contents at '%s'",
+                     self.pypirc_file_path)
+        with open(self.pypirc_file_path, "r", encoding="utf8") as f:
+            text = f.read()
+        if not self.REGEX_PATTERN.match(text):
+            logger.error(
+                ".pypirc file contents validation failed for '%s'", self.pypirc_file_path)
+            raise RuntimeError(
+                f"{self.__class__.__name__} checked the contents of '{self.pypirc_file_path}' and it failed to match the following regex: r\"{self.REGEX_PATTERN.pattern}\"")
+        logger.debug(
+            ".pypirc file contents validation passed for '%s'", self.pypirc_file_path)
+
+    def __init__(self, pypirc_file_path: str = "./.pypirc", verbose: bool = False) -> None:
+        super().__init__(verbose)
+        self.pypirc_file_path = pypirc_file_path
+        logger.info("Initialized PypircUploadTarget with pypirc_file_path='%s', verbose=%s",
+                    pypirc_file_path, verbose)
+
+
+__all__ = [
+    "PypircUploadTarget"
+]

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quickpub
-Version: 3.0.5
+Version: 3.0.61
 Summary: A python package to quickly configure and publish a new package
 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)