aws-durable-execution-sdk-python 1.4.0__tar.gz → 1.5.0__tar.gz

aws_durable_execution_sdk_python-1.5.0/.github/scripts/__init__.py

@@ -0,0 +1 @@
+

{aws_durable_execution_sdk_python-1.4.0/ops → aws_durable_execution_sdk_python-1.5.0/.github/scripts}/ci-checks.sh

@@ -13,3 +13,6 @@ echo SUCCESS: typings
 # static analysis
 hatch fmt
 echo SUCCESS: linting/fmt
+
+# commit message validation
+hatch run python .github/scripts/lintcommit.py

aws_durable_execution_sdk_python-1.5.0/.github/scripts/lintcommit.py

@@ -0,0 +1,265 @@
+#!/usr/bin/env python3
+# Checks that commit messages conform to conventional commits
+# (https://www.conventionalcommits.org/).
+#
+# To run tests:
+#
+#     python -m pytest .github/scripts/tests/test_lintcommit.py
+
+from __future__ import annotations
+
+import argparse
+import re
+import subprocess
+import sys
+from dataclasses import dataclass, field
+
+TYPES: set[str] = {
+    "build",
+    "chore",
+    "ci",
+    "deps",
+    "docs",
+    "feat",
+    "fix",
+    "perf",
+    "refactor",
+    "style",
+    "test",
+}
+
+MAX_SUBJECT_LENGTH: int = 50
+MAX_SCOPE_LENGTH: int = 30
+MAX_BODY_LINE_LENGTH: int = 72
+
+
+def validate_subject(subject_line: str) -> str | None:
+    """Validate a commit message subject line.
+
+    Returns None if valid, else an error message string.
+    """
+    parts: list[str] = subject_line.split(":", maxsplit=1)
+
+    if len(parts) < 2:
+        return "missing colon (:) char"
+
+    type_scope: str = parts[0]
+    subject: str = parts[1].strip()
+
+    # Parse type and optional scope: type or type(scope)
+    scope: str | None = None
+    commit_type: str = type_scope
+
+    if "(" in type_scope:
+        paren_start: int = type_scope.index("(")
+        commit_type = type_scope[:paren_start]
+
+        if not type_scope.endswith(")"):
+            return "must be formatted like type(scope):"
+
+        scope = type_scope[paren_start + 1 : -1]
+
+    if " " in commit_type:
+        return f'type contains whitespace: "{commit_type}"'
+
+    if commit_type not in TYPES:
+        return f'invalid type "{commit_type}"'
+
+    if scope is not None:
+        if len(scope) > MAX_SCOPE_LENGTH:
+            return f"invalid scope (must be <={MAX_SCOPE_LENGTH} chars)"
+
+        if re.search(r"[^- a-z0-9]", scope):
+            return f'invalid scope (must be lowercase, ascii only): "{scope}"'
+
+    if len(subject) == 0:
+        return "empty subject"
+
+    if len(subject) > MAX_SUBJECT_LENGTH:
+        return f"invalid subject (must be <={MAX_SUBJECT_LENGTH} chars)"
+
+    if subject.endswith("."):
+        return "subject must not end with a period"
+
+    return None
+
+
+def validate_body(body: str) -> list[str]:
+    """Validate the body of a commit message.
+
+    Returns a list of warnings (not hard errors) for body issues.
+    """
+    warnings: list[str] = []
+    for i, line in enumerate(body.splitlines(), start=1):
+        if len(line) > MAX_BODY_LINE_LENGTH:
+            warnings.append(
+                f"body line {i} exceeds {MAX_BODY_LINE_LENGTH} chars ({len(line)} chars)"
+            )
+    return warnings
+
+
+def validate_message(message: str) -> tuple[str | None, list[str]]:
+    """Validate a full commit message (subject + optional body).
+
+    Returns (error, warnings) where error is None if the subject is valid.
+    """
+    lines: list[str] = message.strip().splitlines()
+    if not lines:
+        return ("empty commit message", [])
+
+    subject_line: str = lines[0]
+    error: str | None = validate_subject(subject_line)
+
+    warnings: list[str] = []
+    # Check for blank line between subject and body
+    body_start: int = 2
+    if len(lines) > 1 and lines[1].strip() != "":
+        warnings.append("missing blank line between subject and body")
+        body_start = 1
+
+    if len(lines) > body_start:
+        body: str = "\n".join(lines[body_start:])
+        warnings.extend(validate_body(body))
+
+    return (error, warnings)
+
+
+@dataclass
+class CommitResult:
+    """Result of validating a single commit."""
+
+    sha: str
+    subject: str
+    error: str | None = None
+    warnings: list[str] = field(default_factory=list)
+
+
+@dataclass
+class LintResult:
+    """Result of linting a range of commits."""
+
+    commits: list[CommitResult] = field(default_factory=list)
+    skipped: bool = False
+    skip_reason: str = ""
+    empty: bool = False
+    git_error: str = ""
+
+    @property
+    def has_errors(self) -> bool:
+        return bool(self.git_error) or any(c.error for c in self.commits)
+
+
+def lint_range(git_range: str, *, skip_dirty_check: bool = False) -> LintResult:
+    """Validate commit messages in a git range (e.g. 'origin/main..HEAD').
+
+    Args:
+        git_range: A git revision range like 'origin/main..HEAD'.
+        skip_dirty_check: When True, skip the uncommitted changes check
+            (useful in CI where the worktree may be clean by definition).
+
+    Returns:
+        A LintResult with per-commit validation results.
+    """
+    if not skip_dirty_check:
+        status = subprocess.run(
+            ["git", "status", "--porcelain"],
+            capture_output=True,
+            text=True,
+        )
+        if status.stdout.strip():
+            return LintResult(
+                skipped=True,
+                skip_reason=(
+                    "uncommitted changes detected, skipping commit message validation.\n"
+                    "Commit your changes and re-run to validate."
+                ),
+            )
+
+    result = subprocess.run(
+        ["git", "log", "--no-merges", git_range, "-z", "--format=%H%n%B"],
+        capture_output=True,
+        text=True,
+    )
+    if result.returncode != 0:
+        return LintResult(git_error=result.stderr.strip())
+
+    if not result.stdout.strip():
+        return LintResult(empty=True)
+
+    commits: list[CommitResult] = []
+    for record in result.stdout.split("\0"):
+        if not record.strip():
+            continue
+        sha, _, message = record.partition("\n")
+        message = message.strip()
+        if not message:
+            continue
+
+        error, warnings = validate_message(message)
+        subject = message.splitlines()[0]
+        commits.append(
+            CommitResult(
+                sha=sha[:7],
+                subject=subject,
+                error=error,
+                warnings=warnings,
+            )
+        )
+
+    return LintResult(commits=commits)
+
+
+def write_output(lint_result: LintResult, git_range: str) -> None:
+    """Write lint results to stdout/stderr."""
+    if lint_result.skipped:
+        print(f"WARNING: {lint_result.skip_reason}")
+        return
+
+    if lint_result.git_error:
+        print(f"git log failed: {lint_result.git_error}", file=sys.stderr)
+        return
+
+    if lint_result.empty:
+        print(f"No commits in range {git_range}")
+        return
+
+    for commit in lint_result.commits:
+        if commit.error:
+            print(f"FAIL {commit.sha}: {commit.subject}", file=sys.stderr)
+            print(f"  Error: {commit.error}", file=sys.stderr)
+        else:
+            print(f"PASS {commit.sha}: {commit.subject}")
+
+        for warning in commit.warnings:
+            print(f"  Warning: {warning}")
+
+
+def run_range(git_range: str, *, skip_dirty_check: bool = False) -> None:
+    """Validate commit messages in a git range and exit on errors."""
+    lint_result = lint_range(git_range, skip_dirty_check=skip_dirty_check)
+    write_output(lint_result, git_range)
+    if lint_result.has_errors:
+        sys.exit(1)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="Lint commit messages for conventional commits compliance."
+    )
+    parser.add_argument(
+        "--range",
+        default=None,
+        dest="git_range",
+        help="Validate all commits in a git revision range (e.g. 'origin/main..HEAD'). "
+        "Skips the uncommitted-changes check (useful in CI).",
+    )
+    args = parser.parse_args()
+
+    if args.git_range is not None:
+        run_range(args.git_range, skip_dirty_check=True)
+    else:
+        run_range("origin/main..HEAD")
+
+
+if __name__ == "__main__":
+    main()

aws_durable_execution_sdk_python-1.5.0/.github/scripts/tests/__init__.py

@@ -0,0 +1 @@
+

aws_durable_execution_sdk_python-1.5.0/.github/scripts/tests/test_lintcommit.py

@@ -0,0 +1,261 @@
+#!/usr/bin/env python3
+
+from __future__ import annotations
+
+import os
+import sys
+from subprocess import CompletedProcess
+from unittest.mock import patch
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(__file__)))
+
+import pytest
+
+from lintcommit import lint_range, validate_message, validate_subject
+
+
+# region validate_subject: valid subjects
+
+
+def test_valid_feat() -> None:
+    assert validate_subject("feat: add new feature") is None
+
+
+def test_valid_fix() -> None:
+    assert validate_subject("fix: resolve issue") is None
+
+
+def test_valid_fix_with_scope() -> None:
+    assert validate_subject("fix(sdk): resolve issue") is None
+
+
+def test_valid_build() -> None:
+    assert validate_subject("build: update build process") is None
+
+
+def test_valid_chore() -> None:
+    assert validate_subject("chore: update dependencies") is None
+
+
+def test_valid_ci() -> None:
+    assert validate_subject("ci: configure ci/cd") is None
+
+
+def test_valid_deps() -> None:
+    assert validate_subject("deps: bump aws-sdk group with 5 updates") is None
+
+
+def test_valid_docs() -> None:
+    assert validate_subject("docs: update documentation") is None
+
+
+def test_valid_feat_with_scope() -> None:
+    assert validate_subject("feat(sdk): add new feature") is None
+
+
+def test_valid_feat_scope_bar() -> None:
+    assert validate_subject("feat(sdk): bar") is None
+
+
+def test_valid_feat_foo() -> None:
+    assert validate_subject("feat: foo") is None
+
+
+def test_valid_fix_foo() -> None:
+    assert validate_subject("fix: foo") is None
+
+
+# region validate_subject: invalid subjects
+
+
+def test_invalid_type() -> None:
+    assert validate_subject("config: foo") == 'invalid type "config"'
+
+
+def test_missing_colon() -> None:
+    assert validate_subject("invalid title") == "missing colon (:) char"
+
+
+def test_period_at_end() -> None:
+    assert validate_subject("feat: add thing.") == "subject must not end with a period"
+
+
+def test_empty_subject() -> None:
+    assert validate_subject("feat: ") == "empty subject"
+
+
+def test_subject_too_long() -> None:
+    long_subject: str = "feat: " + "a" * 51
+    result = validate_subject(long_subject)
+    assert result is not None
+    assert "invalid subject" in result
+
+
+def test_type_with_whitespace() -> None:
+    assert validate_subject("fe at: foo") == 'type contains whitespace: "fe at"'
+
+
+def test_scope_not_closed() -> None:
+    assert validate_subject("feat(sdk: foo") == "must be formatted like type(scope):"
+
+
+def test_scope_too_long() -> None:
+    long_scope: str = "a" * 31
+    result = validate_subject(f"feat({long_scope}): foo")
+    assert result is not None
+    assert "invalid scope" in result
+
+
+def test_scope_uppercase() -> None:
+    result = validate_subject("feat(SDK): foo")
+    assert result is not None
+    assert "invalid scope" in result
+
+
+def test_subject_uppercase() -> None:
+    assert validate_subject("feat: Add new feature") == "subject must be lowercase"
+
+
+# region validate_message
+
+
+def test_valid_subject_only() -> None:
+    error, warnings = validate_message("feat: add thing")
+    assert error is None
+    assert warnings == []
+
+
+def test_valid_with_body() -> None:
+    error, warnings = validate_message("feat: add thing\n\nThis is the body.")
+    assert error is None
+    assert warnings == []
+
+
+def test_missing_blank_line() -> None:
+    _, warnings = validate_message("feat: add thing\nNo blank line.")
+    assert "missing blank line between subject and body" in warnings
+
+
+def test_missing_blank_line_body_still_checked() -> None:
+    _, warnings = validate_message("feat: add thing\n" + "x" * 80)
+    assert "missing blank line between subject and body" in warnings
+    assert any("exceeds 72 chars" in w for w in warnings), (
+        "body line length should be checked even without blank line"
+    )
+
+
+def test_long_body_line() -> None:
+    _, warnings = validate_message("feat: add thing\n\n" + "x" * 80)
+    assert len(warnings) == 1
+    assert "exceeds 72 chars" in warnings[0]
+
+
+def test_empty_message() -> None:
+    error, _ = validate_message("")
+    assert error == "empty commit message"
+
+
+def test_invalid_subject_in_message() -> None:
+    error, _ = validate_message("invalid title")
+    assert error == "missing colon (:) char"
+
+
+# region lint_range
+
+
+def _make_git_log_output(*messages: str) -> str:
+    """Build fake ``git log --no-merges -z --format=%H%n%B`` output.
+
+    Records are separated by null characters.
+    """
+    records: list[str] = []
+    for i, msg in enumerate(messages):
+        sha = f"abc{i:04d}" + "0" * 33  # 40-char fake SHA
+        records.append(f"{sha}\n{msg}\n")
+    return "\0".join(records)
+
+
+def _completed(
+    stdout: str = "", stderr: str = "", returncode: int = 0
+) -> CompletedProcess[str]:
+    """Shorthand for a ``subprocess.CompletedProcess``."""
+    return CompletedProcess(
+        args=[], returncode=returncode, stdout=stdout, stderr=stderr
+    )
+
+
+@patch("subprocess.run")
+def test_lint_range_all_valid(mock_run) -> None:
+    log_output = _make_git_log_output(
+        "feat: add new feature",
+        "fix(sdk): resolve issue",
+    )
+    mock_run.return_value = _completed(stdout=log_output)
+
+    result = lint_range("origin/main..HEAD", skip_dirty_check=True)
+
+    assert not result.has_errors
+    assert len(result.commits) == 2
+    assert all(c.error is None for c in result.commits)
+
+
+@patch("subprocess.run")
+def test_lint_range_with_invalid_commit(mock_run) -> None:
+    log_output = _make_git_log_output(
+        "feat: add new feature",
+        "bad commit no colon",
+    )
+    mock_run.return_value = _completed(stdout=log_output)
+
+    result = lint_range("origin/main..HEAD", skip_dirty_check=True)
+
+    assert result.has_errors
+    assert result.commits[0].error is None
+    assert result.commits[1].error == "missing colon (:) char"
+
+
+@patch("subprocess.run")
+def test_lint_range_empty(mock_run) -> None:
+    mock_run.return_value = _completed(stdout="")
+
+    result = lint_range("origin/main..HEAD", skip_dirty_check=True)
+
+    assert result.empty
+    assert not result.has_errors
+
+
+@patch("subprocess.run")
+def test_lint_range_git_failure(mock_run) -> None:
+    mock_run.return_value = _completed(returncode=1, stderr="fatal: bad range")
+
+    result = lint_range("bad..range", skip_dirty_check=True)
+
+    assert result.has_errors
+    assert result.git_error == "fatal: bad range"
+
+
+@patch("subprocess.run")
+def test_lint_range_dirty_worktree_skips(mock_run) -> None:
+    """When skip_dirty_check=False and worktree is dirty, validation is skipped."""
+    mock_run.return_value = _completed(stdout=" M .github/scripts/lintcommit.py\n")
+
+    result = lint_range("origin/main..HEAD", skip_dirty_check=False)
+
+    assert result.skipped
+    assert "uncommitted changes" in result.skip_reason
+    # git log should never have been called (only git status)
+    mock_run.assert_called_once()
+
+
+@patch("subprocess.run")
+def test_lint_range_warnings_collected(mock_run) -> None:
+    log_output = _make_git_log_output(
+        "feat: add thing\n\n" + "x" * 80,
+    )
+    mock_run.return_value = _completed(stdout=log_output)
+
+    result = lint_range("origin/main..HEAD", skip_dirty_check=True)
+
+    assert not result.has_errors
+    assert len(result.commits) == 1
+    assert any("exceeds 72 chars" in w for w in result.commits[0].warnings)

{aws_durable_execution_sdk_python-1.4.0 → aws_durable_execution_sdk_python-1.5.0}/.github/workflows/ci.yml

@@ -13,21 +13,20 @@ on:
 
 jobs:
   lint-commits:
-    # Note: To re-run `lint-commits` after fixing the PR title, close-and-reopen the PR.
+    if: github.event_name == 'pull_request'
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd  # v6.0.2
-      - name: Use Node.js
-        uses: actions/setup-node@53b83947a5a98c8d113130e565377fae1a50d02f # v6.3.0
-        with:
-          node-version: 22.x
-      - name: Check PR title
-        run: |
-          node "$GITHUB_WORKSPACE/.github/workflows/lintcommit.js"
+    - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd  # v6.0.2
+      with:
+        fetch-depth: 0
+    - name: Set up Python
+      uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
+      with:
+        python-version: "3.12"
+    - name: Lint commit messages
+      run: python .github/scripts/lintcommit.py --range "origin/${{ github.event.pull_request.base.ref }}..${{ github.event.pull_request.head.sha }}"
 
   build:
-    needs: lint-commits
-
     runs-on: ubuntu-latest
     strategy:
       fail-fast: false