quickpub 4.1.1__tar.gz → 4.1.2__tar.gz

quickpub-4.1.2/PKG-INFO

@@ -0,0 +1,232 @@
+Metadata-Version: 2.4
+Name: quickpub
+Version: 4.1.2
+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)
+
+Catch publish failures on your machine before they hit CI or PyPI.
+
+QuickPub runs pre-publish checks, quality tools, tests, packaging, and upload in one pipeline — so broken releases fail locally with fast feedback.
+
+## The problem
+
+Publishing a Python package usually means juggling several steps: validate project files, run mypy/pylint/pytest, bump the version, generate packaging files, build the sdist, upload to PyPI. Miss a step and you find out in CI — or worse, after a bad release.
+
+QuickPub wires those steps together. You define your package once; it enforces constraints, runs QA across Python environments, builds, and uploads.
+
+## Install
+
+```bash
+pip install quickpub
+```
+
+With [uv](https://docs.astral.sh/uv/):
+
+```bash
+uv add quickpub
+```
+
+Requires Python **3.8+** (tested on 3.8–3.13).
+
+## Quick start
+
+Add a `publish.py` in your project root:
+
+```python
+from quickpub import (
+    publish,
+    MypyRunner,
+    PylintRunner,
+    PytestRunner,
+    SetuptoolsBuildSchema,
+    PypircUploadTarget,
+    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()],
+)
+```
+
+### uv / `pyproject.toml` projects (important)
+
+If the project already has a PEP 621 `pyproject.toml` (uv, Hatch, Poetry, PDM), **do not** use the default file generation. `publish()` would overwrite `pyproject.toml` and wipe `[dependency-groups]`, `[tool.uv]`, `[tool.mypy]`, and other toolchain config.
+
+Use `UvBuildSchema` and `generate_project_files=False`:
+
+```python
+from quickpub import (
+    publish,
+    UvBuildSchema,
+    PypircUploadTarget,
+    PypircEnforcer,
+    ReadmeEnforcer,
+    LicenseEnforcer,
+    LocalVersionEnforcer,
+    PypiRemoteVersionEnforcer,
+    MypyRunner,
+    PylintRunner,
+    PytestRunner,
+)
+
+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=[UvBuildSchema()],
+    generate_project_files=False,
+    upload_targets=[PypircUploadTarget()],
+)
+```
+
+That keeps the existing `pyproject.toml`, bumps only `[project].version` and `__init__.__version__`, and builds with `uv build`. See [this repo's `publish.py`](publish.py).
+
+Run it:
+
+```bash
+python publish.py
+```
+
+**Dry run** — validate and run QA without building or uploading:
+
+```python
+publish(..., demo=True)
+```
+
+PyPI upload needs a valid `.pypirc`. See [this repo's `publish.py`](publish.py) for a full working example.
+
+## What runs
+
+When you call `publish()`, QuickPub runs these stages in order:
+
+1. **Enforcers** — checks README, LICENSE, `.pypirc`, and local/PyPI version consistency
+2. **Quality assurance** — mypy, pylint, pytest, and unittest with configurable score bounds, in parallel across detected Python environments
+3. **File generation** — by default writes `setup.py`, `pyproject.toml`, `MANIFEST.in`, and updates `__init__.py`. Pass `generate_project_files=False` to keep an existing `pyproject.toml` (only `[project].version` and `__init__.__version__` are updated).
+4. **Build & upload** — builds the sdist (`SetuptoolsBuildSchema` or `UvBuildSchema`) and uploads via twine (and optionally pushes to GitHub)
+
+Skip build and upload with `demo=True`.
+
+## Environment detection
+
+By default, QuickPub detects your toolchain from the project root:
+
+| 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"]),
+    ]),
+)
+```
+
+For full control, pass `package_manager` and `python_interpreter_provider` explicitly, or call `resolve_publish_environment()` before `publish()`.
+
+## CLI
+
+QuickPub installs a `quickpub` command that wraps `publish()` via [Fire](https://github.com/google/python-fire). For most projects, a `publish.py` script is easier to maintain than long CLI invocations.
+
+## Development
+
+To work on QuickPub itself, clone the repo and use uv:
+
+```bash
+git clone https://github.com/danielnachumdev/quickpub.git
+cd quickpub
+uv sync
+uv run pytest
+```
+
+## License
+
+MIT — see [LICENSE](LICENSE).

quickpub-4.1.2/README.md

@@ -0,0 +1,191 @@
+# 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)
+
+Catch publish failures on your machine before they hit CI or PyPI.
+
+QuickPub runs pre-publish checks, quality tools, tests, packaging, and upload in one pipeline — so broken releases fail locally with fast feedback.
+
+## The problem
+
+Publishing a Python package usually means juggling several steps: validate project files, run mypy/pylint/pytest, bump the version, generate packaging files, build the sdist, upload to PyPI. Miss a step and you find out in CI — or worse, after a bad release.
+
+QuickPub wires those steps together. You define your package once; it enforces constraints, runs QA across Python environments, builds, and uploads.
+
+## Install
+
+```bash
+pip install quickpub
+```
+
+With [uv](https://docs.astral.sh/uv/):
+
+```bash
+uv add quickpub
+```
+
+Requires Python **3.8+** (tested on 3.8–3.13).
+
+## Quick start
+
+Add a `publish.py` in your project root:
+
+```python
+from quickpub import (
+    publish,
+    MypyRunner,
+    PylintRunner,
+    PytestRunner,
+    SetuptoolsBuildSchema,
+    PypircUploadTarget,
+    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()],
+)
+```
+
+### uv / `pyproject.toml` projects (important)
+
+If the project already has a PEP 621 `pyproject.toml` (uv, Hatch, Poetry, PDM), **do not** use the default file generation. `publish()` would overwrite `pyproject.toml` and wipe `[dependency-groups]`, `[tool.uv]`, `[tool.mypy]`, and other toolchain config.
+
+Use `UvBuildSchema` and `generate_project_files=False`:
+
+```python
+from quickpub import (
+    publish,
+    UvBuildSchema,
+    PypircUploadTarget,
+    PypircEnforcer,
+    ReadmeEnforcer,
+    LicenseEnforcer,
+    LocalVersionEnforcer,
+    PypiRemoteVersionEnforcer,
+    MypyRunner,
+    PylintRunner,
+    PytestRunner,
+)
+
+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=[UvBuildSchema()],
+    generate_project_files=False,
+    upload_targets=[PypircUploadTarget()],
+)
+```
+
+That keeps the existing `pyproject.toml`, bumps only `[project].version` and `__init__.__version__`, and builds with `uv build`. See [this repo's `publish.py`](publish.py).
+
+Run it:
+
+```bash
+python publish.py
+```
+
+**Dry run** — validate and run QA without building or uploading:
+
+```python
+publish(..., demo=True)
+```
+
+PyPI upload needs a valid `.pypirc`. See [this repo's `publish.py`](publish.py) for a full working example.
+
+## What runs
+
+When you call `publish()`, QuickPub runs these stages in order:
+
+1. **Enforcers** — checks README, LICENSE, `.pypirc`, and local/PyPI version consistency
+2. **Quality assurance** — mypy, pylint, pytest, and unittest with configurable score bounds, in parallel across detected Python environments
+3. **File generation** — by default writes `setup.py`, `pyproject.toml`, `MANIFEST.in`, and updates `__init__.py`. Pass `generate_project_files=False` to keep an existing `pyproject.toml` (only `[project].version` and `__init__.__version__` are updated).
+4. **Build & upload** — builds the sdist (`SetuptoolsBuildSchema` or `UvBuildSchema`) and uploads via twine (and optionally pushes to GitHub)
+
+Skip build and upload with `demo=True`.
+
+## Environment detection
+
+By default, QuickPub detects your toolchain from the project root:
+
+| 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"]),
+    ]),
+)
+```
+
+For full control, pass `package_manager` and `python_interpreter_provider` explicitly, or call `resolve_publish_environment()` before `publish()`.
+
+## CLI
+
+QuickPub installs a `quickpub` command that wraps `publish()` via [Fire](https://github.com/google/python-fire). For most projects, a `publish.py` script is easier to maintain than long CLI invocations.
+
+## Development
+
+To work on QuickPub itself, clone the repo and use uv:
+
+```bash
+git clone https://github.com/danielnachumdev/quickpub.git
+cd quickpub
+uv sync
+uv run pytest
+```
+
+## License
+
+MIT — see [LICENSE](LICENSE).

quickpub-4.1.2/pyproject.toml

@@ -0,0 +1,148 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "quickpub"
+version = "4.1.2"
+authors = [
+    { name = "danielnachumdev", email = "danielnachumdev@gmail.com" },
+]
+dependencies = [
+    "danielutils>=1.1.23",
+    "requests",
+    "fire",
+    "twine",
+]
+keywords = []
+license = { "file" = "./LICENSE" }
+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 = [
+	"Development Status :: 3 - Alpha",
+	"Intended Audience :: Developers",
+	"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"]
+
+[project.urls]
+"Homepage" = "https://github.com/danielnachumdev/quickpub"
+"Bug Tracker" = "https://github.com/danielnachumdev/quickpub/issues"
+
+[dependency-groups]
+dev = [
+    "githooklib>=1.0.0",
+    "tqdm",
+    "pylint",
+    "mypy",
+    "types-tqdm",
+    "types-requests",
+    "beautifulsoup4",
+    "setuptools",
+    "black",
+]
+test = [
+    "pytest",
+    "pytest-xdist",
+    "pytest-asyncio",
+    "pytest-cov",
+]
+
+[tool.uv]
+default-groups = ["dev", "test"]
+
+[tool.pytest.ini_options]
+asyncio_default_fixture_loop_scope = "function"
+testpaths = ["tests"]
+python_files = ["test_*.py"]
+python_classes = ["Test*"]
+python_functions = ["test_*"]
+addopts = [
+    "-q",
+    "--strict-markers",
+    "--tb=short",
+    "--cov",
+    "--cov-report=html",
+    "--cov-report=term-missing",
+    "--color=yes",
+    "--durations=10",
+    "--maxfail=10",
+]
+markers = [
+    "unit: Unit tests",
+    "integration: Integration tests",
+    "slow: Slow running tests",
+]
+
+[tool.coverage.run]
+source = ["quickpub"]
+branch = false
+parallel = false
+
+[tool.coverage.report]
+precision = 2
+show_missing = true
+skip_covered = false
+fail_under = 50
+sort = "Cover"
+
+[tool.coverage.html]
+directory = "htmlcov"
+
+[tool.mypy]
+disallow_untyped_calls = true
+check_untyped_defs = true
+no_implicit_optional = true
+strict_optional = true
+namespace_packages = true
+explicit_package_bases = true
+files = ["quickpub/*.py", "tests", "publish.py"]
+
+[[tool.mypy.overrides]]
+module = "*"
+ignore_missing_imports = true
+
+[tool.pylint.main]
+ignore-paths = ["^tests/.*", "^tmp/.*"]
+
+[tool.pylint.basic]
+good-names = ["foo", "bar"]
+good-names-rgxs = ["^[a-zA-Z]"]
+
+[tool.pylint.naming]
+class-rgx = "^(_)?[A-Z][a-zA-Z0-9]*$"
+module-rgx = "^[a-zA-Z][a-zA-Z0-9_]*$"
+
+[tool.pylint.messages_control]
+disable = [
+    "W0211",
+    "C0114",
+    "E1120",
+    "E0611",
+    "W0702",
+    "W0612",
+    "R0913",
+    "C0415",
+    "R0912",
+    "R0903",
+    "R0914",
+    "R0911",
+    "R1716",
+    "W0401",
+    "R0801",
+    "C0116",
+    "W0212",
+    "C0115",
+]
+
+[tool.pylint.format]
+max-line-length = 120

{quickpub-4.1.1 → quickpub-4.1.2}/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.1"
+__version__ = "4.1.2"

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

@@ -25,7 +25,13 @@ from .validators import (
     validate_source,
 )
 from .structures import Version, Dependency
-from .files import create_toml, create_setup, create_manifest, add_version_to_init
+from .files import (
+    create_toml,
+    create_setup,
+    create_manifest,
+    add_version_to_init,
+    update_pyproject_version,
+)
 from .classifiers import *
 from .qa import qa, SupportsProgress
 from .logging_ import setup_logging
@@ -155,6 +161,15 @@ def _create_package_files(
     add_version_to_init(src_folder_path=explicit_src_folder_path, version=version)
 
 
+def _sync_existing_package_metadata(
+    explicit_src_folder_path: str,
+    version: Version,
+    pyproject_path: str = "./pyproject.toml",
+) -> None:
+    update_pyproject_version(version=version, pyproject_path=pyproject_path)
+    add_version_to_init(src_folder_path=explicit_src_folder_path, version=version)
+
+
 def _build_and_upload_packages(
     build_schemas: List[BuildSchema],
     upload_targets: List[UploadTarget],
@@ -193,6 +208,7 @@ def publish(
     scripts: Optional[Dict[str, Callable]] = None,
     pbar: Optional[SupportsProgress] = None,
     demo: bool = False,
+    generate_project_files: bool = True,
     config: Optional[Any] = None,
 ) -> None:
     start_time = time.perf_counter()
@@ -222,21 +238,27 @@ def publish(
             pbar,
             package_manager,
         )
-        _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,
-        )
+        if generate_project_files:
+            _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,
+            )
+        else:
+            _sync_existing_package_metadata(
+                validated_src_path,
+                validated_version,
+            )
         _build_and_upload_packages(
             build_schemas, upload_targets, name, validated_version, demo
         )

quickpub-4.1.2/quickpub/dist_files.py

@@ -0,0 +1,33 @@
+import re
+from pathlib import Path
+from typing import List, Union
+
+from .enforcers import ExitEarlyError
+from .structures import Version
+
+
+def normalize_dist_name(name: str) -> str:
+    return re.sub(r"[-_.]+", "-", name).lower()
+
+
+def find_sdist(
+    dist_dir: Union[str, Path],
+    name: str,
+    version: Union[str, Version],
+) -> Path:
+    dist_path = Path(dist_dir)
+    version_str = str(version)
+    candidates: List[Path] = []
+    for candidate_name in (name, normalize_dist_name(name)):
+        candidate = dist_path / f"{candidate_name}-{version_str}.tar.gz"
+        if candidate not in candidates:
+            candidates.append(candidate)
+    for candidate in candidates:
+        if candidate.exists():
+            return candidate
+    raise ExitEarlyError(
+        f"Could not find sdist for '{name}' version '{version_str}' in '{dist_path}'"
+    )
+
+
+__all__ = ["normalize_dist_name", "find_sdist"]