DefStream 0.1.3__tar.gz → 0.1.3.4__tar.gz

defstream-0.1.3.4/.github/workflows/ci.yml

@@ -0,0 +1,403 @@
+name: CI
+
+on:
+  pull_request:
+    branches: [master]
+  push:
+    branches: [master]
+
+permissions:
+  contents: read
+
+env:
+  RELEASE_SERIES: '0.1'
+
+concurrency:
+  group: ci-${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: false
+
+jobs:
+  changes:
+    name: Plan release version
+    runs-on: ubuntu-latest
+    timeout-minutes: 5
+    outputs:
+      release: ${{ steps.changes.outputs.release }}
+      version: ${{ steps.changes.outputs.version }}
+    steps:
+      - uses: actions/checkout@v7
+        with:
+          fetch-depth: 0
+          persist-credentials: false
+      - name: Set up release planner Python
+        uses: actions/setup-python@v7
+        with:
+          python-version: '3.13'
+      - name: Check complete push range and plan version
+        id: changes
+        env:
+          BEFORE: ${{ github.event.before }}
+          RELEASE_PUSH: ${{ github.event_name == 'push' && github.ref == 'refs/heads/master' }}
+        run: |
+          python - <<'PY'
+          from os import environ
+          from pathlib import Path
+          from re import fullmatch
+          from subprocess import check_output
+
+          if environ['RELEASE_PUSH'] != 'true':
+              with Path(environ['GITHUB_OUTPUT']).open('a', encoding='utf-8') as output:
+                  output.write('release=false\n')
+              raise SystemExit(0)
+          series = environ['RELEASE_SERIES']
+          if fullmatch(r'(0|[1-9]\d*)\.(0|[1-9]\d*)', series) is None:
+              raise ValueError(f'Invalid RELEASE_SERIES: {series!r}')
+          before = environ['BEFORE']
+          if not before:
+              raise ValueError('Missing push base commit')
+          first_push = set(before) == {'0'}
+          base = check_output(['git', 'hash-object', '-t', 'tree', '--stdin'], input='', text=True).strip() if first_push else before
+          changed = check_output(
+              ['git', 'diff', '--name-only', '--no-renames', base, environ['GITHUB_SHA'], '--', 'src/'],
+              text=True,
+          ).strip()
+          # Anchor to the pre-push history so a rerun ignores its own release tag.
+          tags = [] if first_push else check_output(['git', 'tag', '--merged', before], text=True).splitlines()
+          releases = []
+          for tag in tags:
+              match = fullmatch(r'v?(\d+)\.(\d+)\.(\d+)(?:\.(\d+))?(?:\.post\d+)?', tag)
+              if match and f'{int(match[1])}.{int(match[2])}' == series:
+                  releases.append(tuple(map(int, match.groups()[:3])) + (int(match[4] or 0),))
+          latest = max(releases) if releases else None
+          number = int(environ['GITHUB_RUN_NUMBER'])
+          if number < 1:
+              raise ValueError('Build number must be positive')
+          if latest is not None and number <= latest[3]:
+              raise ValueError('Build number must exceed the previous build; do not reset the workflow counter')
+          if changed:
+              patch = latest[2] + 1 if latest is not None else 0
+              print(f'Source changes:\n{changed}')
+          else:
+              if latest is None:
+                  raise ValueError(
+                      'No release tag in pre-push history for this series. '
+                      'Tag the exact source commit of the existing PyPI release before retrying.'
+                  )
+              patch = latest[2]
+              print('No src changes: keeping MAJOR.MINOR.PATCH and increasing BUILD')
+          version = f'{series}.{patch}.{number}'
+          print(f'Planned version: {version}')
+          with Path(environ['GITHUB_OUTPUT']).open('a', encoding='utf-8') as output:
+              output.write(f'release=true\nversion={version}\n')
+          PY
+
+  test:
+    name: Test Python ${{ matrix.python }}
+    needs: changes
+    runs-on: ubuntu-latest
+    timeout-minutes: 25
+    strategy:
+      fail-fast: false
+      matrix:
+        python: ['3.9', '3.10', '3.11', '3.12', '3.13', '3.14']
+    env:
+      PROJECT: ${{ github.event.repository.name }}
+      DEFSTREAM_RABBITMQ_TESTS: '1'
+      DEFSTREAM_REDIS_TESTS: '1'
+    services:
+      rabbitmq:
+        image: rabbitmq:4.1
+        ports:
+          - 5672:5672
+        env:
+          RABBITMQ_DEFAULT_USER: guest
+          RABBITMQ_DEFAULT_PASS: guest
+          RABBITMQ_SERVER_ADDITIONAL_ERL_ARGS: '-rabbit loopback_users []'
+        options: >-
+          --health-cmd "rabbitmq-diagnostics -q ping"
+          --health-interval 10s
+          --health-timeout 10s
+          --health-retries 12
+      redis:
+        image: redis:7.4
+        ports:
+          - 6379:6379
+        options: >-
+          --health-cmd "redis-cli ping"
+          --health-interval 5s
+          --health-timeout 5s
+          --health-retries 12
+    steps:
+      - name: Check out core
+        uses: actions/checkout@v7
+        with:
+          repository: yong5eon/DefStream
+          ref: ${{ github.event.repository.name == 'DefStream' && github.sha || 'master' }}
+          path: packages/DefStream
+          fetch-depth: 0
+          persist-credentials: false
+
+      - name: Check out RabbitMQ adapter
+        uses: actions/checkout@v7
+        with:
+          repository: yong5eon/DefStream-RabbitMQ
+          ref: ${{ github.event.repository.name == 'DefStream-RabbitMQ' && github.sha || 'master' }}
+          path: packages/DefStream-RabbitMQ
+          fetch-depth: 0
+          persist-credentials: false
+
+      - name: Check out Redis adapter
+        uses: actions/checkout@v7
+        with:
+          repository: yong5eon/DefStream-Redis
+          ref: ${{ github.event.repository.name == 'DefStream-Redis' && github.sha || 'master' }}
+          path: packages/DefStream-Redis
+          fetch-depth: 0
+          persist-credentials: false
+
+      - name: Set up Python
+        uses: actions/setup-python@v7
+        with:
+          python-version: ${{ matrix.python }}
+
+      - name: Record source commits and tag candidate locally
+        env:
+          RELEASE_BUILD: ${{ needs.changes.outputs.release }}
+          RELEASE_VERSION: ${{ needs.changes.outputs.version }}
+        run: |
+          for package in packages/*; do
+            echo "$package: $(git -C "$package" rev-parse HEAD)"
+          done
+          echo "SOURCE_DATE_EPOCH=$(git -C "packages/$PROJECT" show -s --format=%ct HEAD)" >> "$GITHUB_ENV"
+          python - <<'PY'
+          from os import environ
+          from pathlib import Path
+          from re import fullmatch
+          from subprocess import check_output, run
+
+          project = environ['PROJECT']
+          if project not in ('DefStream', 'DefStream-RabbitMQ', 'DefStream-Redis'):
+              raise ValueError(f'Unexpected project: {project}')
+          if environ['RELEASE_BUILD'] != 'true':
+              print('Test-only build: using the existing Git-derived development version.')
+              raise SystemExit(0)
+          version = environ['RELEASE_VERSION']
+          if fullmatch(r'(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)\.[1-9]\d*', version) is None:
+              raise ValueError(f'Invalid planned version: {version!r}')
+          path = Path('packages') / project
+          tag = version
+          tags = check_output(['git', '-C', str(path), 'tag', '--list', tag], text=True).strip()
+          if tags:
+              tagged = check_output(['git', '-C', str(path), 'rev-parse', f'{tag}^{{commit}}'], text=True).strip()
+              if tagged != environ['GITHUB_SHA']:
+                  raise RuntimeError(f'{tag} already points at another commit')
+          else:
+              run(['git', '-C', str(path), 'tag', tag, environ['GITHUB_SHA']], check=True)
+          print(f'{project}: local candidate {tag}')
+          with Path(environ['GITHUB_STEP_SUMMARY']).open('a', encoding='utf-8') as summary:
+              summary.write(f'## {project} {version}\n\nSource: `{environ["GITHUB_SHA"]}`\n')
+          PY
+
+      - name: Install build tools
+        run: python -m pip install --upgrade build twine
+
+      - name: Build source distributions and wheels
+        run: |
+          mkdir -p dist dependency-wheels
+          for name in DefStream DefStream-RabbitMQ DefStream-Redis; do
+            if [ "$name" = "$PROJECT" ]; then
+              python -m build --outdir "$GITHUB_WORKSPACE/dist" "packages/$name"
+            else
+              python -m build --outdir "$GITHUB_WORKSPACE/dependency-wheels" "packages/$name"
+            fi
+          done
+          python -m twine check --strict dist/*
+
+      - name: Install built wheels into a clean environment
+        run: |
+          python -m venv "$RUNNER_TEMP/installed"
+          "$RUNNER_TEMP/installed/bin/python" -m pip install dist/*.whl dependency-wheels/*.whl
+          "$RUNNER_TEMP/installed/bin/python" -m pip check
+
+      - name: Test installed package
+        run: |
+          cd "$RUNNER_TEMP"
+          "$RUNNER_TEMP/installed/bin/python" -m unittest discover \
+            -s "$GITHUB_WORKSPACE/packages/$PROJECT/test" -p 'test_*.py' -v
+
+      - name: Set up Node for core UI tests
+        if: env.PROJECT == 'DefStream'
+        uses: actions/setup-node@v7
+        with:
+          node-version: '22'
+
+      - name: Test core UI
+        if: env.PROJECT == 'DefStream'
+        run: node --test packages/DefStream/test/test_dashboard_ui.cjs
+
+      - name: Preserve verified release distributions
+        if: needs.changes.outputs.release == 'true' && matrix.python == '3.13'
+        uses: actions/upload-artifact@v7
+        with:
+          name: distributions
+          path: dist/*
+          if-no-files-found: error
+          retention-days: 14
+
+  publish:
+    name: Publish PyPI
+    if: github.event_name == 'push' && github.ref == 'refs/heads/master' && needs.changes.outputs.release == 'true'
+    needs: [changes, test]
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    environment: pypi
+    permissions:
+      contents: write
+    steps:
+      - name: Check out release source for tagging
+        uses: actions/checkout@v7
+        with:
+          ref: ${{ github.sha }}
+          path: release-source
+          fetch-depth: 0
+
+      - name: Download verified distributions
+        uses: actions/download-artifact@v8
+        with:
+          name: distributions
+          path: dist
+
+      - name: Set up Python
+        uses: actions/setup-python@v7
+        with:
+          python-version: '3.13'
+
+      - name: Check release status
+        id: release
+        env:
+          PROJECT: ${{ github.event.repository.name }}
+          RELEASE_VERSION: ${{ needs.changes.outputs.version }}
+        run: |
+          python - <<'PY'
+          from email.parser import BytesParser
+          from json import load
+          from os import environ
+          from pathlib import Path
+          from urllib.error import HTTPError
+          from urllib.request import urlopen
+          from zipfile import ZipFile
+
+          wheels = list(Path('dist').glob('*.whl'))
+          sources = list(Path('dist').glob('*.tar.gz'))
+          if len(wheels) != 1 or len(sources) != 1:
+              raise ValueError('Expected exactly one wheel and one source distribution')
+          with ZipFile(wheels[0]) as archive:
+              metadata_path, = (name for name in archive.namelist() if name.endswith('.dist-info/METADATA'))
+              metadata = BytesParser().parsebytes(archive.read(metadata_path))
+          project = environ['PROJECT']
+          if metadata['Name'] != project:
+              raise ValueError(f'Unexpected distribution: {metadata["Name"]}')
+          version = metadata['Version']
+          expected_version = environ['RELEASE_VERSION']
+          if version != expected_version:
+              raise ValueError(f'Expected {expected_version}, got {version}')
+          try:
+              with urlopen(f'https://pypi.org/pypi/{project}/{version}/json', timeout=30) as response:
+                  release = load(response)
+          except HTTPError as error:
+              if error.code != 404:
+                  raise
+              exists = False
+          else:
+              expected = {wheels[0].name, sources[0].name}
+              published = {file['filename'] for file in release['urls']}
+              if int(environ['GITHUB_RUN_ATTEMPT']) == 1 or not expected.issubset(published):
+                  raise RuntimeError(
+                      f'{project} {version} already exists or is partially published. '
+                      'Do not overwrite it; use a new run/version or repair the release manually.'
+                  )
+              print(f'{project} {version}: already published; skipping this rerun')
+              exists = True
+          with Path(environ['GITHUB_OUTPUT']).open('a', encoding='utf-8') as output:
+              output.write(f'publish={str(not exists).lower()}\n')
+              output.write(f'version={version}\n')
+          PY
+
+      - name: Record verified release tag
+        env:
+          VERSION: ${{ steps.release.outputs.version }}
+        run: |
+          tag="$VERSION"
+          cd release-source
+          if git show-ref --verify --quiet "refs/tags/$tag"; then
+            if [ "$(git rev-parse "$tag^{commit}")" != "$GITHUB_SHA" ]; then
+              echo "::error::$tag already points at another commit."
+              exit 1
+            fi
+          else
+            git tag "$tag" "$GITHUB_SHA"
+          fi
+          git push origin "refs/tags/$tag"
+
+      - name: Install upload tool
+        if: steps.release.outputs.publish == 'true'
+        run: python -m pip install --upgrade twine
+
+      - name: Upload to PyPI
+        if: steps.release.outputs.publish == 'true'
+        env:
+          TWINE_USERNAME: __token__
+          TWINE_PASSWORD: ${{ secrets.PYPI_API_TOKEN }}
+        run: |
+          if [ -z "$TWINE_PASSWORD" ]; then
+            echo "::error::Configure PYPI_API_TOKEN in the pypi environment or repository Actions secrets."
+            exit 1
+          fi
+          python -m twine upload --non-interactive dist/*
+
+      - name: Publish GitHub Release with verified distributions
+        env:
+          GH_TOKEN: ${{ github.token }}
+          VERSION: ${{ steps.release.outputs.version }}
+        run: |
+          python - <<'PY'
+          from json import load
+          from os import environ
+          from pathlib import Path
+          from subprocess import run
+          from urllib.error import HTTPError
+          from urllib.parse import quote
+          from urllib.request import Request, urlopen
+
+          repository = environ['GITHUB_REPOSITORY']
+          version = environ['VERSION']
+          request = Request(
+              f'{environ["GITHUB_API_URL"]}/repos/{repository}/releases/tags/{quote(version, safe="")}',
+              headers={
+                  'Authorization': f'Bearer {environ["GH_TOKEN"]}',
+                  'Accept': 'application/vnd.github+json',
+                  'X-GitHub-Api-Version': '2022-11-28',
+              },
+          )
+          try:
+              with urlopen(request, timeout=30) as response:
+                  release = load(response)
+          except HTTPError as error:
+              if error.code != 404:
+                  raise
+              run([
+                  'gh', 'release', 'create', version, '--repo', repository,
+                  '--verify-tag', '--title', version, '--generate-notes', '--draft',
+              ], check=True)
+          else:
+              if release['tag_name'] != version:
+                  raise ValueError('GitHub Release does not match the verified version')
+          artifacts = sorted(str(path) for path in Path('dist').iterdir() if path.is_file())
+          run([
+              'gh', 'release', 'upload', version, '--repo', repository,
+              '--clobber', *artifacts,
+          ], check=True)
+          run([
+              'gh', 'release', 'edit', version, '--repo', repository, '--draft=false',
+          ], check=True)
+          PY

defstream-0.1.3.4/.gitignore

@@ -0,0 +1,62 @@
+# Python bytecode and caches
+__pycache__/
+*.py[codz]
+*$py.class
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+.tox/
+.nox/
+.coverage
+.coverage.*
+
+# Virtual environments and local environment files
+.venv/
+venv/
+env/
+.env
+.env.*
+
+# Python packaging and build artifacts
+build/
+dist/
+*.egg-info/
+*.egg
+.Python
+
+# Local broker adapter links
+/src/Broker/Implements/*
+!/src/Broker/Implements/__init__.py
+
+# Operating system files
+.DS_Store
+Thumbs.db
+Desktop.ini
+
+# Miscellaneous files
+*.log
+*.tmp
+*.bak
+*.swp
+*.swo
+
+# Temporary files
+tmp/
+*.tmp
+*.temp
+
+# IDE and editor specific files
+.vscode/
+.idea/
+
+# Git
+.git/
+
+# GitHub specific files
+.github/
+!/.github/
+/.github/*
+!/.github/workflows/
+
+# GitLab specific files
+.gitlab/

{defstream-0.1.3 → defstream-0.1.3.4}/DefStream.egg-info/PKG-INFO

@@ -1,11 +1,12 @@
 Metadata-Version: 2.4
 Name: DefStream
-Version: 0.1.3
+Version: 0.1.3.4
 Summary: Synchronous message processing with pluggable broker adapters
 Home-page: https://github.com/yong5eon/DefStream
 Author: Heo Yongseon
 Project-URL: Source, https://github.com/yong5eon/DefStream
 Project-URL: Issues, https://github.com/yong5eon/DefStream/issues
+Project-URL: Releases, https://github.com/yong5eon/DefStream/releases
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
@@ -38,7 +39,19 @@ The `CI` workflow runs on pull requests targeting `master` and pushes to
 `master`. Python 3.9 through 3.14 build the distributions, install the wheels in
 a clean virtual environment, and run this repository's tests against RabbitMQ
 4.1 and Redis 7.4 service containers. The core JavaScript UI tests also run.
-Only a successful `master` push can publish to PyPI.
+Every successful `master` push publishes to PyPI; PRs only run tests.
+Source additions,
+deletions, and renames are detected across the entire push range; the first
+push compares against an empty tree. A failed or unavailable base comparison
+fails the workflow rather than assuming that there were no source changes.
+Release versions and tags use `MAJOR.MINOR.PATCH.BUILD`, for example
+`0.1.3.123`. Changes to `src/**` increment PATCH by one; changes only to tests,
+documentation, samples, workflows, or `setup.py` keep MAJOR.MINOR.PATCH.
+BUILD is the Actions run number in both cases:
+`0.1.3.123` -> `0.1.3.124` (docs) -> `0.1.4.125` (source).
+The entire four-part value is the public PyPI version, not hidden metadata.
+Every upload has a distinct version; PyPI files are never overwritten.
+Older three-part and `v`-prefixed tags remain readable; new tags have no prefix.
 
 The workflow checks out the current repository's event commit and the other
 two `yong5eon/DefStream*` repositories at `master`, recording all commit IDs in
@@ -47,12 +60,48 @@ All three packages are built locally, so the first release does not depend on
 existing PyPI releases. This tests the source combination, not compatibility
 with previously published dependency versions.
 
-For a push, `VERSION` must contain `major.minor.patch`; the build replaces its
-patch component with `github.run_number` (for example, `0.1.0` becomes `0.1.42`
-on run 42). PR builds retain the checked-in version. No version commit, PR, or
-Git tag is created. Change the major/minor in `VERSION` when starting a new
-release series. Run numbers can have gaps; renaming/replacing this workflow or
-switching an existing package to this scheme requires checking for collisions.
+There is no `VERSION` or `pyproject.toml` file. `setup.py` declares
+`setuptools-scm` through `setup_requires` and configures the tag format.
+Build with `python -m build`, which resolves that build dependency in an
+isolated environment; the legacy declaration may emit a deprecation warning.
+`setuptools-scm` derives the package version from Git tags using full history.
+On every master push, CI creates a local candidate tag
+`<RELEASE_SERIES>.<PATCH>.<github.run_number>` (for example, `0.1.4.125`).
+`RELEASE_SERIES` is configured in the workflow; change it to start a new
+major/minor series. PATCH is calculated from the highest matching version tag
+in the pre-push history, increasing only when source files change.
+The planner uses tags reachable from the push's `before` commit so reruns do
+not accidentally base themselves on their own new tag. PR builds use the
+existing Git-derived development version without creating candidate tags.
+No version commit or version-update PR is created. A new release series starts
+at PATCH 0 on a source-changing push; non-source pushes require an existing
+matching release tag. Build counter regressions fail rather than uploading an
+older build. Legacy `.postN` tags are still accepted when determining PATCH;
+four-part numeric builds sort above post releases of a three-part base.
+
+After all tests pass, the publish job pushes the release tag to the exact
+tested commit, then uploads the verified distributions. A tag can therefore
+exist before a failed upload is retried; check PyPI or the job result for
+publication status. An existing tag on another commit is an error and is
+never overwritten. Run numbers can have gaps; check for collisions before
+renaming/replacing this workflow.
+
+After PyPI upload succeeds (or a rerun confirms the version is already fully
+published), CI creates a GitHub Release with the same version as its title and
+tag, automatically generated release notes, and the verified wheel and sdist
+as assets. New releases stay in draft until both assets are uploaded. If this
+step fails, rerun the workflow: it reuses the existing release and replaces
+matching assets with the verified files before publishing. A failed PyPI
+upload never proceeds to GitHub Release creation. PyPI's project links include
+the GitHub Releases page for change history. No additional GitHub token secret
+is needed; release creation uses the job's write-enabled `GITHUB_TOKEN`.
+
+Local release checkouts use their tag version. Commits after a tag produce
+development versions, and dirty trees get a local version suffix. Fetch tags
+with `git fetch --tags`; build from a Git checkout or the published sdist,
+not a GitHub source ZIP without Git metadata. The sdist carries the version
+in its package metadata and can be rebuilt without `.git`. Query installed
+versions with `importlib.metadata.version('DefStream')`.
 
 After every Python matrix entry passes, the publish job downloads the exact
 Python 3.13 distributions already built and tested. A fully published version
@@ -68,6 +117,9 @@ Before enabling automatic releases:
    appropriate PyPI project scope once the project exists. Never commit tokens.
 2. Configure the `pypi` environment to allow deployments only from `master`.
    Do not require manual approval if fully automatic deployment is desired.
+   Allow the workflow's `GITHUB_TOKEN` to write repository contents so the
+   publish job can create numeric version tags. Tag rulesets must permit this
+   workflow for four-part version tags.
 3. Protect `master`, require PRs, and require all six `Test Python 3.x` checks.
    Do not require `Publish PyPI`, which intentionally does not run on PRs.
 4. Keep the workflow filename/name stable and review changes to workflows and
@@ -75,6 +127,15 @@ Before enabling automatic releases:
 
 Dependencies still need to be published before end users can install adapters
 from PyPI. For the initial release, publish DefStream before its adapters.
+Before migrating to SCM versions, tag each already published release's exact
+source commit as `<its-PyPI-version>` and push those tags. Do not point a
+release tag at an unrelated newer commit. The shared CI builds sibling
+`master` sources: an untagged SCM dependency can resolve to `0.1.dev...`, below
+its required minimum. These initial tags supply the starting PATCH when
+migration changes no source files. For example, tag the commit used to publish
+`0.1.3` as `0.1.3`; a later docs-only run 123 produces `0.1.3.123`.
+This tag is a historical source/version link, not a source edit or a new PyPI
+upload. Never invent that link by tagging an arbitrary current commit.
 
 **Just def.**<br>
 **Let workers do the work.**<br>

{defstream-0.1.3 → defstream-0.1.3.4}/DefStream.egg-info/SOURCES.txt

@@ -1,13 +1,19 @@
+.gitignore
 LICENSE
-MANIFEST.in
 README.md
-VERSION
 setup.py
+.github/workflows/ci.yml
 DefStream.egg-info/PKG-INFO
 DefStream.egg-info/SOURCES.txt
 DefStream.egg-info/dependency_links.txt
 DefStream.egg-info/requires.txt
 DefStream.egg-info/top_level.txt
+sample/Broker/Sample.py
+sample/Worker/Sample.py
+sample/Worker/RabbitMQ/Client.py
+sample/Worker/RabbitMQ/Tasks.py
+sample/Worker/RabbitMQ/Worker.py
+sample/Worker/Redis/Sample.py
 src/__init__.py
 src/Broker/Configuration.py
 src/Broker/Connection.py
@@ -58,6 +64,7 @@ src/Worker/Specification.py
 src/Worker/Worker.py
 src/Worker/__init__.py
 test/test_dashboard.py
+test/test_dashboard_ui.cjs
 test/test_inspector.py
 test/test_inspector_console.py
 test/test_lifecycle_hooks.py