plotnine 0.14.4__tar.gz → 0.15.0.dev1__tar.gz

plotnine-0.15.0.dev1/.github/utils/_repo.py

@@ -0,0 +1,219 @@
+#!/usr/bin/env python
+from __future__ import annotations
+
+import os
+import re
+import shlex
+from subprocess import PIPE, Popen
+from typing import Sequence
+
+# https://docs.github.com/en/actions/learn-github-actions/variables
+# #default-environment-variables
+GITHUB_VARS = [
+    "GITHUB_REF_NAME",  # main, dev, v0.1.0, v0.1.3a1
+    "GITHUB_REF_TYPE",  # "branch" or "tag"
+    "GITHUB_REPOSITORY",  # has2k1/scikit-misc
+    "GITHUB_SERVER_URL",  # https://github.com
+    "GITHUB_SHA",  # commit shasum
+    "GITHUB_WORKSPACE",  # /home/runner/work/scikit-misc/scikit-misc
+    "GITHUB_EVENT_NAME",  # push, schedule, workflow_dispatch, ...
+]
+
+
+count = r"(?:[0-9]|[1-9][0-9]+)"
+DESCRIBE_PATTERN = re.compile(
+    r"^v"
+    rf"(?P<version>{count}\.{count}\.{count})"
+    rf"(?P<pre>(a|b|rc|alpha|beta){count})?"
+    r"(-(?P<commits>\d+)-g(?P<hash>[a-z0-9]+))?"
+    r"(?P<dirty>-dirty)?"
+    r"$"
+)
+
+# Define a releasable version to be valid according to PEP440
+# and is a semver
+RELEASE_TAG_PATTERN = re.compile(r"^v" rf"{count}\.{count}\.{count}" r"$")
+
+# Prerelease version
+PRE_RELEASE_TAG_PATTERN = re.compile(
+    r"^v"
+    rf"{count}\.{count}\.{count}"
+    r"(?:"
+    rf"(?:a|b|rc|alpha|beta|dev){count}"
+    r")"
+    r"$"
+)
+
+# development version
+DEV_RELEASE_TAG_PATTERN = re.compile(
+    rf"^v{count}\.{count}\.{count}\.dev{count}$"
+)
+
+
+def run(cmd: str | Sequence[str]) -> str:
+    if isinstance(cmd, str) and os.name == "posix":
+        cmd = shlex.split(cmd)
+    with Popen(
+        cmd, stdin=PIPE, stderr=PIPE, stdout=PIPE, text=True, encoding="utf-8"
+    ) as p:
+        stdout, _ = p.communicate()
+    return stdout.strip()
+
+
+class Git:
+    @staticmethod
+    def checkout(committish):
+        """
+        Return True if inside a git repo
+        """
+        res = run(f"git checkout {committish}")
+        return res
+
+    @staticmethod
+    def commit_subjects(n=1) -> list[str]:
+        """
+        Return a list n of commit subjects
+        """
+        output = run(
+            f"git log --oneline --no-merges --pretty='format:%s' -{n}"
+        )
+        return output.split("\n")[:n]
+
+    @staticmethod
+    def commit_messages(n=1) -> list[str]:
+        """
+        Return a list n of commit messages
+        """
+        sep = "______ MESSAGE _____"
+        output = run(
+            f"git log --no-merges --pretty='format:%B{sep}' -{n}"
+        ).strip()
+        if output.endswith(sep):
+            output = output[: -len(sep)]
+        return output.split(sep)[:n]
+
+    @staticmethod
+    def commit_subject() -> str:
+        """
+        Commit subject
+        """
+        return Git.commit_subjects(1)[0]
+
+    @staticmethod
+    def commit_message() -> str:
+        """
+        Commit message
+        """
+        return Git.commit_messages(1)[0]
+
+    @staticmethod
+    def is_repo():
+        """
+        Return True if inside a git repo
+        """
+        res = run("git rev-parse --is-inside-work-tree")
+        return res == "return"
+
+    @staticmethod
+    def fetch_tags() -> str:
+        """
+        Fetch all tags
+        """
+        return run("git fetch --tags --force")
+
+    @staticmethod
+    def is_shallow() -> bool:
+        """
+        Return True if current repo is shallow
+        """
+        res = run("git rev-parse --is-shallow-repository")
+        return res == "true"
+
+    @staticmethod
+    def deepen(n: int = 1) -> str:
+        """
+        Fetch n commits beyond the shallow limit
+        """
+        return run(f"git fetch --deepen={n}")
+
+    @staticmethod
+    def describe() -> str:
+        """
+        Git describe to determine version
+        """
+        return run("git describe --dirty --tags --long --match '*[0-9]*'")
+
+    @staticmethod
+    def can_describe() -> bool:
+        """
+        Return True if repo can be "described" from a semver tag
+        """
+        return bool(DESCRIBE_PATTERN.match(Git.describe()))
+
+    @staticmethod
+    def get_tag_at_commit(committish: str) -> str:
+        """
+        Get tag of a given commit
+        """
+        return run(f"git describe --exact-match {committish}")
+
+    @staticmethod
+    def tag_message(tag: str) -> str:
+        """
+        Get the message of a tag
+        """
+        return run(f"git tag -l --format='%(subject)' {tag}")
+
+    @staticmethod
+    def is_annotated(tag: str) -> bool:
+        """
+        Return true if tag is annotated tag
+        """
+        # LHS prints to stderr and returns nothing when
+        # tag is an empty string
+        return run(f"git cat-file -t {tag}") == "tag"
+
+    @staticmethod
+    def shallow_checkout(branch: str, url: str, depth: int = 1) -> str:
+        """
+        Shallow clone upto n commits
+        """
+        _branch = f"--branch={branch}"
+        _depth = f"--depth={depth}"
+        return run(f"git clone {_depth} {_branch} {url} .")
+
+    @staticmethod
+    def is_release():
+        """
+        Return True if event is a release
+        """
+        ref = os.environ.get("GITHUB_REF_NAME", "")
+        ref_type = os.environ.get("GITHUB_REF_TYPE", "")
+        return ref_type == "tag" and bool(RELEASE_TAG_PATTERN.match(ref))
+
+    @staticmethod
+    def is_pre_release():
+        """
+        Return True if event is a release
+        """
+        ref = os.environ.get("GITHUB_REF_NAME", "")
+        ref_type = os.environ.get("GITHUB_REF_TYPE", "")
+        return ref_type == "tag" and bool(PRE_RELEASE_TAG_PATTERN.match(ref))
+
+    @staticmethod
+    def is_dev_release():
+        """
+        Return True if event is a release
+        """
+        ref = os.environ.get("GITHUB_REF_NAME", "")
+        ref_type = os.environ.get("GITHUB_REF_TYPE", "")
+        return ref_type == "tag" and bool(DEV_RELEASE_TAG_PATTERN.match(ref))
+
+    @staticmethod
+    def branch():
+        """
+        Return event branch
+        """
+        ref = os.environ.get("GITHUB_REF_NAME", "")
+        ref_type = os.environ.get("GITHUB_REF_TYPE", "")
+        return ref if ref_type == "branch" else ""

plotnine-0.15.0.dev1/.github/utils/please.py

@@ -0,0 +1,55 @@
+import sys
+from typing import Callable, TypeAlias
+
+from _repo import Git
+
+Ask: TypeAlias = Callable[[], bool | str]
+Do: TypeAlias = Callable[[], str]
+
+
+def can_i_deploy_documentation() -> bool:
+    """
+    Return True if documentation should be deployed
+    """
+    return (
+        Git.is_release()
+        or Git.is_pre_release()
+        or Git.branch() in ("main", "dev")
+    )
+
+
+def where_can_i_deploy_documentation() -> str:
+    """
+    Return branch to deploy documentation to
+    """
+    if Git.is_release():
+        return "website"
+    elif Git.is_dev_release() or Git.is_pre_release():
+        return "pre-website"
+    else:
+        return "gh-pages"
+
+
+def process_request(arg: str) -> str:
+    if arg in REQUESTS:
+        result = REQUESTS.get(arg, lambda: False)()
+        if not isinstance(result, str):
+            result = str(result).lower()
+    else:
+        result = ACTIONS.get(arg, lambda: "")()
+    return result
+
+
+REQUESTS: dict[str, Ask] = {
+    "can_i_deploy_documentation": can_i_deploy_documentation,
+    "where_can_i_deploy_documentation": where_can_i_deploy_documentation,
+}
+
+
+ACTIONS: dict[str, Do] = {}
+
+
+if __name__ == "__main__":
+    if len(sys.argv) == 2:
+        arg = sys.argv[1]
+        print(process_request(arg))

plotnine-0.15.0.dev1/.github/workflows/release.yml

@@ -0,0 +1,123 @@
+name: Release
+
+on:
+  push:
+    tags:
+      - 'v[0-9]*'
+
+jobs:
+  run-tests:
+    name: Run all tests
+    uses: ./.github/workflows/testing.yml
+    with:
+      skip_codecov: true
+
+  check-semver-tag:
+    name: Check if the tag is in semantic version format
+    needs: [run-tests]
+    runs-on: ubuntu-latest
+    outputs:
+      tag_type: ${{ steps.check-tag.outputs.tag_type }}
+      publish_on: ${{ steps.check-tag.outputs.publish_on }}
+
+    strategy:
+      matrix:
+        python-version: ["3.13"]
+
+    steps:
+      - name: Checkout Code
+        uses: actions/checkout@v4
+
+      - name: Setup Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install a specific version of uv
+        uses: astral-sh/setup-uv@v3
+        with:
+          version: "latest"
+
+      - name: Make uv use system python
+        run: echo "UV_SYSTEM_PYTHON=true" >> $GITHUB_ENV
+
+      - name: Check for semantic version tag
+        id: check-tag
+        run: python tools/gha_check_semver.py
+
+      - name: See outputs
+        shell: bash
+        run: |
+          echo "tag_type="${{ steps.check-tag.outputs.tag_type }}
+          echo "publish_on="${{ steps.check-tag.outputs.publish_on }}
+
+  # Ref: https://github.com/pypa/gh-action-pypi-publish
+  publish:
+    name: Build and publish Python 🐍 distributions 📦 to TestPyPI or PyPI
+    needs: [check-semver-tag]
+    runs-on: ubuntu-latest
+
+    if: ${{ needs.check-semver-tag.outputs.publish_on != '' }}
+
+    environment:
+      name: release
+      url: https://github.com/has2k1/plotnine
+
+    permissions:
+      id-token: write  # IMPORTANT: this permission is mandatory for trusted publishing
+
+    strategy:
+      matrix:
+        python-version: ["3.13"]
+
+    steps:
+      - name: Checkout Code
+        uses: actions/checkout@v4
+
+      - name: Setup Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install a specific version of uv
+        uses: astral-sh/setup-uv@v3
+        with:
+          version: "latest"
+
+      - name: Make uv use system python
+        run: echo "UV_SYSTEM_PYTHON=true" >> $GITHUB_ENV
+
+      - name: Install Packages
+        run: uv pip install build
+
+      - name: Build a wheel and a source tarball
+        run: make dist
+
+      - name: Publish distribution 📦 to Test PyPI
+        if: ${{ needs.check-semver-tag.outputs.publish_on == 'testpypi' }}
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          repository-url: https://test.pypi.org/legacy/
+          skip-existing: true
+
+      - name: Publish distribution 📦 to PyPI
+        if: ${{ needs.check-semver-tag.outputs.publish_on == 'pypi' }}
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          skip-existing: true
+
+      - name: Build Website (Dev)
+        if: ${{ needs.check-semver-tag.outputs.publish_on == 'testpypi' }}
+        uses: peter-evans/repository-dispatch@v3
+        with:
+          token: ${{ secrets.PLOTNINE_WEBSITE }}
+          repository: has2k1/plotnine.org
+          event-type: plotnine-pre-release
+
+      - name: Build Website
+        if: ${{ needs.check-semver-tag.outputs.publish_on == 'pypi' }}
+        uses: peter-evans/repository-dispatch@v3
+        with:
+          token: ${{ secrets.PLOTNINE_WEBSITE }}
+          repository: has2k1/plotnine.org
+          event-type: plotnine-release

plotnine-0.15.0.dev1/.github/workflows/testing.yml

@@ -0,0 +1,185 @@
+name: build
+
+on:
+  push:
+    branches:
+      - '*'
+    tags-ignore:
+      - 'v[0-9]*'
+  pull_request:
+  workflow_call:
+    inputs:
+      skip_codecov:
+        type: boolean
+        required: false
+        default: false
+jobs:
+  unittests:
+    runs-on: ubuntu-latest
+
+    # We want to run on external PRs, but not on our own internal PRs as they'll be run
+    # by the push to the branch.
+    if: github.event_name == 'push' || github.event.pull_request.head.repo.full_name != github.repository
+
+    strategy:
+      matrix:
+        include:
+          - python-version: "3.10"
+            resolution: "lowest-direct"
+          - python-version: 3.13
+            resolution: "highest"
+    steps:
+      - name: Checkout Code
+        uses: actions/checkout@v4
+
+      - name: Setup Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install a specific version of uv
+        uses: astral-sh/setup-uv@v3
+        with:
+          version: "latest"
+
+      - name: Make uv use system python
+        run: echo "UV_SYSTEM_PYTHON=true" >> $GITHUB_ENV
+
+      - name: Install Packages
+        run: |
+          # Install as an editable so that the coverage path
+          # is predicable
+          uv pip install --resolution=${{ matrix.resolution }} -e ".[extra,test]"
+
+      - name: Environment Information
+        run: |
+          uv pip list
+
+      - name: Run Tests
+        run: |
+          coverage erase
+          make test
+
+      - name: List Directory
+        run: |
+          ls -la
+
+      - uses: actions/upload-artifact@v4
+        if: failure()
+        with:
+          name: result-images
+          path: tests/result_images/
+          if-no-files-found: ignore
+
+      # To change secrets
+      # https://app.codecov.io/github/has2k1/plotnine/settings
+      # https://github.com/has2k1/plotnine/settings/secrets/actions
+      - name: Upload coverage to Codecov
+        if: ${{ !inputs.skip_codecov }}
+        uses: codecov/codecov-action@v4
+        with:
+          name: "py${{ matrix.python-version }}"
+          token: ${{ secrets.CODECOV_TOKEN }}
+          fail_ci_if_error: true
+
+  lint-and-format:
+    runs-on: ubuntu-latest
+
+    # We want to run on external PRs, but not on our own internal PRs as they'll be run
+    # by the push to the branch.
+    if: github.event_name == 'push' || github.event.pull_request.head.repo.full_name != github.repository
+
+    strategy:
+      matrix:
+        python-version: [3.13]
+    steps:
+      - name: Checkout Code
+        uses: actions/checkout@v4
+
+      - name: Setup Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install a specific version of uv
+        uses: astral-sh/setup-uv@v3
+        with:
+          version: "latest"
+
+      - name: Make uv use system python
+        run: echo "UV_SYSTEM_PYTHON=true" >> $GITHUB_ENV
+
+      - name: Install Packages
+        run: uv tool install ruff
+
+      - name: Environment Information
+        run: uv pip list
+
+      - name: Check lint with Ruff
+        shell: bash
+        run: |
+          make lint
+
+      - name: Check format with Ruff
+        shell: bash
+        run: |
+          make format
+
+  typecheck:
+    runs-on: ubuntu-latest
+
+    # We want to run on external PRs, but not on our own internal PRs as they'll be run
+    # by the push to the branch.
+    if: github.event_name == 'push' || github.event.pull_request.head.repo.full_name != github.repository
+
+    strategy:
+      matrix:
+        python-version: [3.13]
+
+    steps:
+      - name: Checkout Code
+        uses: actions/checkout@v4
+
+      - name: Setup Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install a specific version of uv
+        uses: astral-sh/setup-uv@v3
+        with:
+          version: "latest"
+
+      - name: Make uv use system python
+        run: echo "UV_SYSTEM_PYTHON=true" >> $GITHUB_ENV
+
+      - name: Install Packages
+        run: |
+          uv pip install ".[extra, typing]"
+
+      - name: Environment Information
+        run: uv pip list
+
+      - name: Run Tests
+        run: make typecheck
+
+  call-build-documentation:
+    if: |
+      github.event_name == 'push' ||
+      github.event.pull_request.head.repo.full_name != github.repository
+    uses: ./.github/workflows/documentation.yml
+
+  build-website:
+    # Requires all the previous jobs to pass
+    needs: [unittests, lint-and-format, typecheck, call-build-documentation]
+    if: |
+      github.event_name == 'push' &&
+      github.ref == 'refs/heads/main'
+    runs-on: ubuntu-latest
+    steps:
+      - name: Build Website (Dev)
+        uses: peter-evans/repository-dispatch@v3
+        with:
+          token: ${{ secrets.PLOTNINE_WEBSITE }}
+          repository: has2k1/plotnine.org
+          event-type: push-plotnine-main