quickpub 4.1.0__tar.gz → 4.1.1__tar.gz

quickpub-4.1.1/PKG-INFO

@@ -0,0 +1,177 @@
+Metadata-Version: 2.4
+Name: quickpub
+Version: 4.1.1
+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
+        
+        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.
+Project-URL: Homepage, https://github.com/danielnachumdev/quickpub
+Project-URL: Bug Tracker, https://github.com/danielnachumdev/quickpub/issues
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: Microsoft :: Windows
+Requires-Python: >=3.8.0
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: danielutils>=1.1.23
+Requires-Dist: requests
+Requires-Dist: fire
+Requires-Dist: twine
+Dynamic: license-file
+
+# QuickPub
+
+[![Python 3.8+](https://img.shields.io/badge/python-3.8+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
+
+Run quality checks, tests, and packaging locally before you publish a Python package.
+
+QuickPub validates versions and project files, runs QA tools (mypy, pylint, pytest, unittest), builds the sdist, and uploads to PyPI/GitHub — so failures show up on your machine, not in CI.
+
+## Requirements
+
+- Python **3.8+**
+- Tested on **3.8, 3.9, 3.10, 3.11, 3.12, 3.13** (see [CI](.github/workflows/ci.yml))
+
+## Install
+
+[uv](https://docs.astral.sh/uv/) is the recommended workflow:
+
+```bash
+git clone https://github.com/danielnachumdev/quickpub.git
+cd quickpub
+uv sync
+```
+
+Runtime-only install:
+
+```bash
+uv sync --no-group dev --no-group test
+```
+
+Use as a CLI in another project:
+
+```bash
+uv add quickpub
+```
+
+## Usage
+
+### Publish this repo
+
+```bash
+uv run python publish.py
+```
+
+Requires a valid `.pypirc` for PyPI upload. Set `demo=True` in `publish.py` to run checks without building or uploading.
+
+### Publish your own package
+
+`publish()` runs enforcers, QA, file generation, build, and upload in one call:
+
+```python
+from quickpub import (
+    publish,
+    MypyRunner,
+    PylintRunner,
+    PytestRunner,
+    SetuptoolsBuildSchema,
+    PypircUploadTarget,
+    GithubUploadTarget,
+    PypircEnforcer,
+    ReadmeEnforcer,
+    LicenseEnforcer,
+    LocalVersionEnforcer,
+    PypiRemoteVersionEnforcer,
+)
+
+publish(
+    name="my-package",
+    version="1.0.0",
+    author="Your Name",
+    author_email="you@example.com",
+    description="My package",
+    homepage="https://github.com/you/my-package",
+    dependencies=["requests>=2.25.0"],
+    min_python="3.8.0",
+    enforcers=[
+        PypircEnforcer(),
+        ReadmeEnforcer(),
+        LicenseEnforcer(),
+        LocalVersionEnforcer(),
+        PypiRemoteVersionEnforcer(),
+    ],
+    global_quality_assurance_runners=[
+        MypyRunner(bound="<=20"),
+        PylintRunner(bound=">=0.8"),
+        PytestRunner(bound=">=0.95"),
+    ],
+    build_schemas=[SetuptoolsBuildSchema()],
+    upload_targets=[PypircUploadTarget(), GithubUploadTarget()],
+)
+```
+
+Omit `python_interpreter_provider` and `package_manager` to auto-detect the environment:
+
+| Project layout | Package manager | Python provider |
+|---|---|---|
+| `uv.lock` present | `UvPackageManager` | `UvPythonProvider` |
+| otherwise | `PipPackageManager` | `DefaultPythonProvider` |
+
+Override for conda or mixed setups:
+
+```python
+from quickpub import CondaPythonProvider, UnionProvider
+
+publish(
+    ...,
+    python_interpreter_provider=UnionProvider([
+        CondaPythonProvider(["base", "py39", "py38"]),
+    ]),
+)
+```
+
+Manual control: `resolve_publish_environment()` or explicit `package_manager` / `python_interpreter_provider` arguments.
+
+## What it does
+
+**Enforcers** — README, LICENSE, `.pypirc`, local/PyPI version checks.
+
+**QA runners** — mypy, pylint, pytest, unittest with configurable score bounds; runs in parallel across environments.
+
+**Build & upload** — generates `setup.py` / `pyproject.toml` / `MANIFEST.in`, builds sdist, uploads via twine and/or git push.
+
+**Environment providers** — `DefaultPythonProvider`, `UvPythonProvider`, `CondaPythonProvider`, or `UnionProvider` to combine them.
+
+## Development
+
+```bash
+uv run pytest          # full test suite
+uv run python publish.py  # publish quickpub itself
+```
+
+Tool config lives in `pyproject.toml` (`pytest`, `mypy`, `pylint`, `coverage`).
+
+## License
+
+MIT — see [LICENSE](LICENSE).

quickpub-4.1.1/README.md

@@ -0,0 +1,136 @@
+# QuickPub
+
+[![Python 3.8+](https://img.shields.io/badge/python-3.8+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
+
+Run quality checks, tests, and packaging locally before you publish a Python package.
+
+QuickPub validates versions and project files, runs QA tools (mypy, pylint, pytest, unittest), builds the sdist, and uploads to PyPI/GitHub — so failures show up on your machine, not in CI.
+
+## Requirements
+
+- Python **3.8+**
+- Tested on **3.8, 3.9, 3.10, 3.11, 3.12, 3.13** (see [CI](.github/workflows/ci.yml))
+
+## Install
+
+[uv](https://docs.astral.sh/uv/) is the recommended workflow:
+
+```bash
+git clone https://github.com/danielnachumdev/quickpub.git
+cd quickpub
+uv sync
+```
+
+Runtime-only install:
+
+```bash
+uv sync --no-group dev --no-group test
+```
+
+Use as a CLI in another project:
+
+```bash
+uv add quickpub
+```
+
+## Usage
+
+### Publish this repo
+
+```bash
+uv run python publish.py
+```
+
+Requires a valid `.pypirc` for PyPI upload. Set `demo=True` in `publish.py` to run checks without building or uploading.
+
+### Publish your own package
+
+`publish()` runs enforcers, QA, file generation, build, and upload in one call:
+
+```python
+from quickpub import (
+    publish,
+    MypyRunner,
+    PylintRunner,
+    PytestRunner,
+    SetuptoolsBuildSchema,
+    PypircUploadTarget,
+    GithubUploadTarget,
+    PypircEnforcer,
+    ReadmeEnforcer,
+    LicenseEnforcer,
+    LocalVersionEnforcer,
+    PypiRemoteVersionEnforcer,
+)
+
+publish(
+    name="my-package",
+    version="1.0.0",
+    author="Your Name",
+    author_email="you@example.com",
+    description="My package",
+    homepage="https://github.com/you/my-package",
+    dependencies=["requests>=2.25.0"],
+    min_python="3.8.0",
+    enforcers=[
+        PypircEnforcer(),
+        ReadmeEnforcer(),
+        LicenseEnforcer(),
+        LocalVersionEnforcer(),
+        PypiRemoteVersionEnforcer(),
+    ],
+    global_quality_assurance_runners=[
+        MypyRunner(bound="<=20"),
+        PylintRunner(bound=">=0.8"),
+        PytestRunner(bound=">=0.95"),
+    ],
+    build_schemas=[SetuptoolsBuildSchema()],
+    upload_targets=[PypircUploadTarget(), GithubUploadTarget()],
+)
+```
+
+Omit `python_interpreter_provider` and `package_manager` to auto-detect the environment:
+
+| Project layout | Package manager | Python provider |
+|---|---|---|
+| `uv.lock` present | `UvPackageManager` | `UvPythonProvider` |
+| otherwise | `PipPackageManager` | `DefaultPythonProvider` |
+
+Override for conda or mixed setups:
+
+```python
+from quickpub import CondaPythonProvider, UnionProvider
+
+publish(
+    ...,
+    python_interpreter_provider=UnionProvider([
+        CondaPythonProvider(["base", "py39", "py38"]),
+    ]),
+)
+```
+
+Manual control: `resolve_publish_environment()` or explicit `package_manager` / `python_interpreter_provider` arguments.
+
+## What it does
+
+**Enforcers** — README, LICENSE, `.pypirc`, local/PyPI version checks.
+
+**QA runners** — mypy, pylint, pytest, unittest with configurable score bounds; runs in parallel across environments.
+
+**Build & upload** — generates `setup.py` / `pyproject.toml` / `MANIFEST.in`, builds sdist, uploads via twine and/or git push.
+
+**Environment providers** — `DefaultPythonProvider`, `UvPythonProvider`, `CondaPythonProvider`, or `UnionProvider` to combine them.
+
+## Development
+
+```bash
+uv run pytest          # full test suite
+uv run python publish.py  # publish quickpub itself
+```
+
+Tool config lives in `pyproject.toml` (`pytest`, `mypy`, `pylint`, `coverage`).
+
+## License
+
+MIT — see [LICENSE](LICENSE).

{quickpub-4.1.0 → quickpub-4.1.1}/pyproject.toml

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

{quickpub-4.1.0 → quickpub-4.1.1}/quickpub/__init__.py

@@ -6,4 +6,4 @@ from .logging_ import set_log_level
 from .package_manager_detection import detect_package_manager, resolve_publish_environment
 from .__main__ import publish, main
 
-__version__ = "4.1.0"
+__version__ = "4.1.1"

{quickpub-4.1.0 → quickpub-4.1.1}/quickpub/__main__.py

@@ -90,7 +90,7 @@ def _run_quality_assurance(
     if package_manager is None:
         package_manager = PipPackageManager()
     try:
-        result = asyncio.get_event_loop().run_until_complete(
+        result = asyncio.run(
             qa(
                 python_interpreter_provider,
                 global_quality_assurance_runners or [],

{quickpub-4.1.0 → quickpub-4.1.1}/quickpub/strategies/implementations/package_managers/installed_package_parser.py

@@ -1,5 +1,5 @@
 import re
-from typing import Dict, Union
+from typing import Dict, List, Union
 
 from ....structures import Dependency, Version
 
@@ -7,7 +7,7 @@ VERSION_REGEX: re.Pattern = re.compile(r"^\d+\.\d+\.\d+$")
 
 
 def parse_installed_packages_output(
-    output_lines: list[str],
+    output_lines: List[str],
 ) -> Dict[str, Union[str, Dependency]]:
     split_lines = (line.split(" ") for line in output_lines[2:])
     version_tuples = [(s[0], s[-1].strip()) for s in split_lines if s[0]]

{quickpub-4.1.0 → quickpub-4.1.1}/quickpub/strategies/implementations/python_providers/default_python_provider.py

@@ -32,7 +32,9 @@ class DefaultPythonProvider(PythonProvider):
         if self.aiter_index == 0:
             self.aiter_index += 1
             logger.info("Using system Python environment")
-            return "system", AsyncLayeredCommand()
+            executor = AsyncLayeredCommand()
+            executor.prev = None
+            return "system", executor
         raise StopAsyncIteration
 
     @classmethod

{quickpub-4.1.0 → quickpub-4.1.1}/quickpub/strategies/implementations/python_providers/union_provider.py

@@ -1,5 +1,5 @@
 import logging
-from typing import List, Tuple
+from typing import List, Set, Tuple
 
 from danielutils.async_.async_layered_command import AsyncLayeredCommand
 
@@ -42,8 +42,8 @@ class UnionProvider(PythonProvider):
 
         raise StopAsyncIteration
 
-    async def _get_available_envs_impl(self) -> set[str]:
-        available_envs: set[str] = set()
+    async def _get_available_envs_impl(self) -> Set[str]:
+        available_envs: Set[str] = set()
         for provider in self.providers:
             available_envs.update(await provider._get_available_envs())
         return available_envs

{quickpub-4.1.0 → quickpub-4.1.1}/quickpub/strategies/implementations/python_providers/uv_python_provider.py

@@ -27,7 +27,9 @@ class UvPythonProvider(PythonProvider):
         if self.aiter_index == 0:
             self.aiter_index += 1
             logger.info("Using uv-managed Python environment")
-            return "uv", AsyncLayeredCommand()
+            executor = AsyncLayeredCommand()
+            executor.prev = None
+            return "uv", executor
         raise StopAsyncIteration
 
     async def _get_available_envs_impl(self) -> Set[str]:

{quickpub-4.1.0 → quickpub-4.1.1}/quickpub/strategies/implementations/quality_assurance_runners/pylint_qa_runner.py

@@ -18,7 +18,7 @@ class PylintRunner(QualityAssuranceRunner):
         with base:
             base(self.package_manager.install_command("pylint"))
 
-    RATING_PATTERN: re.Pattern = re.compile(r".*?([\d\.\/]+)")
+    RATING_PATTERN: re.Pattern = re.compile(r"([\d.]+)/([\d.]+)")
 
     def __init__(
         self,
@@ -52,13 +52,36 @@ class PylintRunner(QualityAssuranceRunner):
     def _calculate_score(
         self, ret: int, lines: List[str], verbose: bool = False
     ) -> float:
-        from quickpub.enforcers import exit_if
-
         logger.debug("Calculating pylint score from analysis results")
 
         if len(lines) == 0:
             logger.debug("No pylint output, returning perfect score: 1.0")
             return 1
+
+        for line in reversed(lines):
+            match = self.RATING_PATTERN.search(line)
+            if match:
+                numerator = float(match.group(1))
+                denominator = float(match.group(2))
+                score = numerator / denominator
+                logger.debug(
+                    "Pylint score calculated: %.3f (%s/%s)",
+                    score,
+                    match.group(1),
+                    match.group(2),
+                )
+                return score
+
+        if ret == 0:
+            return 1.0
+
+        joined_output = "\n".join(lines)
+        if ret == 1 and "parse-error" in joined_output:
+            logger.debug(
+                "Pylint reported parse-error with an empty target, returning perfect score: 1.0"
+            )
+            return 1.0
+
         if len(lines) == 1:
             if lines[0].endswith("No module named pylint"):
                 logger.error("Pylint module not found")
@@ -73,20 +96,9 @@ class PylintRunner(QualityAssuranceRunner):
             logger.error("Unexpected pylint error: %s", lines[0])
             raise ExitEarlyError(f"Got an unexpected error: {lines[0]}")
 
-        index = -2
-        if lines[-1] == "\x1b[0m":
-            index += -1
-        rating_line = lines[index]
-        m = self.RATING_PATTERN.match(rating_line)
         msg = f"Failed running Pylint, got exit code {ret}. Try running manually using: {self._build_command('TARGET')}"
-        exit_if(not m, msg)
-        rating_string = m.group(1)  # type:ignore
-        numerator, denominator = rating_string.split("/")
-        score = float(numerator) / float(denominator)
-        logger.debug(
-            "Pylint score calculated: %.3f (%s/%s)", score, numerator, denominator
-        )
-        return score
+        logger.error("Failed to parse pylint rating from output: %s", joined_output)
+        raise ExitEarlyError(msg)
 
 
 __all__ = [

quickpub-4.1.1/quickpub.egg-info/PKG-INFO

@@ -0,0 +1,177 @@
+Metadata-Version: 2.4
+Name: quickpub
+Version: 4.1.1
+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
+        
+        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.
+Project-URL: Homepage, https://github.com/danielnachumdev/quickpub
+Project-URL: Bug Tracker, https://github.com/danielnachumdev/quickpub/issues
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: Microsoft :: Windows
+Requires-Python: >=3.8.0
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: danielutils>=1.1.23
+Requires-Dist: requests
+Requires-Dist: fire
+Requires-Dist: twine
+Dynamic: license-file
+
+# QuickPub
+
+[![Python 3.8+](https://img.shields.io/badge/python-3.8+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
+
+Run quality checks, tests, and packaging locally before you publish a Python package.
+
+QuickPub validates versions and project files, runs QA tools (mypy, pylint, pytest, unittest), builds the sdist, and uploads to PyPI/GitHub — so failures show up on your machine, not in CI.
+
+## Requirements
+
+- Python **3.8+**
+- Tested on **3.8, 3.9, 3.10, 3.11, 3.12, 3.13** (see [CI](.github/workflows/ci.yml))
+
+## Install
+
+[uv](https://docs.astral.sh/uv/) is the recommended workflow:
+
+```bash
+git clone https://github.com/danielnachumdev/quickpub.git
+cd quickpub
+uv sync
+```
+
+Runtime-only install:
+
+```bash
+uv sync --no-group dev --no-group test
+```
+
+Use as a CLI in another project:
+
+```bash
+uv add quickpub
+```
+
+## Usage
+
+### Publish this repo
+
+```bash
+uv run python publish.py
+```
+
+Requires a valid `.pypirc` for PyPI upload. Set `demo=True` in `publish.py` to run checks without building or uploading.
+
+### Publish your own package
+
+`publish()` runs enforcers, QA, file generation, build, and upload in one call:
+
+```python
+from quickpub import (
+    publish,
+    MypyRunner,
+    PylintRunner,
+    PytestRunner,
+    SetuptoolsBuildSchema,
+    PypircUploadTarget,
+    GithubUploadTarget,
+    PypircEnforcer,
+    ReadmeEnforcer,
+    LicenseEnforcer,
+    LocalVersionEnforcer,
+    PypiRemoteVersionEnforcer,
+)
+
+publish(
+    name="my-package",
+    version="1.0.0",
+    author="Your Name",
+    author_email="you@example.com",
+    description="My package",
+    homepage="https://github.com/you/my-package",
+    dependencies=["requests>=2.25.0"],
+    min_python="3.8.0",
+    enforcers=[
+        PypircEnforcer(),
+        ReadmeEnforcer(),
+        LicenseEnforcer(),
+        LocalVersionEnforcer(),
+        PypiRemoteVersionEnforcer(),
+    ],
+    global_quality_assurance_runners=[
+        MypyRunner(bound="<=20"),
+        PylintRunner(bound=">=0.8"),
+        PytestRunner(bound=">=0.95"),
+    ],
+    build_schemas=[SetuptoolsBuildSchema()],
+    upload_targets=[PypircUploadTarget(), GithubUploadTarget()],
+)
+```
+
+Omit `python_interpreter_provider` and `package_manager` to auto-detect the environment:
+
+| Project layout | Package manager | Python provider |
+|---|---|---|
+| `uv.lock` present | `UvPackageManager` | `UvPythonProvider` |
+| otherwise | `PipPackageManager` | `DefaultPythonProvider` |
+
+Override for conda or mixed setups:
+
+```python
+from quickpub import CondaPythonProvider, UnionProvider
+
+publish(
+    ...,
+    python_interpreter_provider=UnionProvider([
+        CondaPythonProvider(["base", "py39", "py38"]),
+    ]),
+)
+```
+
+Manual control: `resolve_publish_environment()` or explicit `package_manager` / `python_interpreter_provider` arguments.
+
+## What it does
+
+**Enforcers** — README, LICENSE, `.pypirc`, local/PyPI version checks.
+
+**QA runners** — mypy, pylint, pytest, unittest with configurable score bounds; runs in parallel across environments.
+
+**Build & upload** — generates `setup.py` / `pyproject.toml` / `MANIFEST.in`, builds sdist, uploads via twine and/or git push.
+
+**Environment providers** — `DefaultPythonProvider`, `UvPythonProvider`, `CondaPythonProvider`, or `UnionProvider` to combine them.
+
+## Development
+
+```bash
+uv run pytest          # full test suite
+uv run python publish.py  # publish quickpub itself
+```
+
+Tool config lives in `pyproject.toml` (`pytest`, `mypy`, `pylint`, `coverage`).
+
+## License
+
+MIT — see [LICENSE](LICENSE).