zprocess 2.26.1__tar.gz → 2.27.1__tar.gz

zprocess-2.27.1/.github/workflows/release-vars.sh

@@ -0,0 +1,47 @@
+# This repository. PyPI and Anaconda test and release package uploads are only done if
+# the repository the workflow is running in matches this (i.e. is not a fork). Optional,
+# if not set, package uploads are skipped.
+export RELEASE_REPO="chrisjbillington/zprocess"
+
+# Username with which to upload conda packages. If not given, anaconda uploads are
+# skipped.
+export ANACONDA_USER="labscript-suite"
+
+# Whether (true or false) to upload releases to PyPI, non-releases to Test PyPI,
+# releases to Anaconda, non-releases to Anaconda test label. Only used if the repository
+# the workflow is running in matches RELEASE_REPO, otherwise uploads are skipped.
+# Anaconda uploads require ANACONDA_USER be specified and ANACONDA_API_TOKEN secret be
+# set. Optional, all default to true.
+export PYPI_UPLOAD=""
+export TESTPYPI_UPLOAD=""
+export ANACONDA_UPLOAD=""
+export TEST_ANACONDA_UPLOAD=""
+
+# Which Python version to use for pure wheel builds, sdists, and as the host Python for
+# cibuildwheel. Optional, defaults to the second-most recent minor Python version.
+export DEFAULT_PYTHON=""
+
+# Comma-separated list of Python versions to build conda packages for. Only used if
+# HAS_ENV_MARKERS=true or PURE=false, otherwise a noarch conda package is built instead.
+# Optional, defaults to all non-end-of-life stable Python minor versions.
+export CONDA_PYTHONS=""
+
+# Environment variable set in the envionment that `cibuildwheel` runs in instructing it
+# which Pythons to build for, as a space-separated list of specifiers in the format
+# specified by `cibuildwheel`. Only used if PURE=false. Optional, defaults to all
+# non-end-of-life stable CPython versions.
+export CIBW_BUILD=""
+
+# Name of Python package. Optional, defaults to name from the package metadata
+export PKGNAME=""
+
+# Version of Python package. Optional, defaults to version from the package metadata
+export PKGVER=""
+
+# Whether the Python package is pure (true) or impure (false). Optional, defaults to
+# false if the setuptools package has extension modules or libraries, otherwise true.
+export PURE=""
+
+# Whether (true or false) the Python package has dependencies that vary by platform or
+# Python version. Optional, Defaults to presence of env markers in package metadata.
+export HAS_ENV_MARKERS=""

zprocess-2.27.1/.github/workflows/release.yml

@@ -0,0 +1,452 @@
+name: Build and Release
+
+on:
+  push:
+    branches:
+      - master
+      - maintenance/*
+    tags:
+      - 'v[0-9]+.[0-9]+.[0-9]+*'
+
+env:
+  OS_LIST_UBUNTU: '["ubuntu-latest"]'
+  OS_LIST_ALL: '["ubuntu-latest", "windows-latest", "macos-latest", "macos-15-intel"]'
+
+
+jobs:
+  configure:
+    name: Configure workflow run
+    runs-on: ubuntu-latest
+    outputs:
+      DEFAULT_PYTHON: ${{ steps.config.outputs.DEFAULT_PYTHON }}
+      CIBW_BUILD: ${{ steps.config.outputs.CIBW_BUILD }}
+      PKGNAME: ${{ steps.config.outputs.PKGNAME }}
+      PKGVER: ${{ steps.config.outputs.PKGVER }}
+      PURE: ${{ steps.config.outputs.PURE }}
+      ANACONDA_USER: ${{ steps.config.outputs.ANACONDA_USER }}
+      CONDA_BUILD_ARGS: ${{ steps.config.outputs.CONDA_BUILD_ARGS }}
+      BUILD_OS_LIST: ${{ steps.config.outputs.BUILD_OS_LIST }}
+      RELEASE: ${{ steps.config.outputs.RELEASE }}
+      TESTPYPI_UPLOAD_THIS_RUN: ${{ steps.config.outputs.TESTPYPI_UPLOAD_THIS_RUN }}
+      PYPI_UPLOAD_THIS_RUN: ${{ steps.config.outputs.PYPI_UPLOAD_THIS_RUN }}
+      TEST_ANACONDA_UPLOAD_THIS_RUN: ${{ steps.config.outputs.TEST_ANACONDA_UPLOAD_THIS_RUN }}
+      ANACONDA_UPLOAD_THIS_RUN: ${{ steps.config.outputs.ANACONDA_UPLOAD_THIS_RUN }}
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v6
+        with:
+          fetch-depth: 0
+
+      - name: Ignore Tags for non-tag pushes
+        if: "!startsWith(github.ref, 'refs/tags/')"
+        run: git tag -d $(git tag --points-at HEAD)
+
+      - name: Install Python
+        uses: actions/setup-python@v6
+        with:
+          python-version: '3.x'
+
+      - name: Configure workflow
+        id: config
+        run: |
+          pip install ci-helper
+
+          # Load repo-specific variables and overrides:
+          VARS_FILE=".github/workflows/release-vars.sh"
+          if [ -f "${VARS_FILE}" ]; then
+            source "${VARS_FILE}"
+          fi
+
+          # Python version used to build sdists, pure wheels, and as host Python for
+          # `cibuildwheel`:
+          if [ -z "${DEFAULT_PYTHON}" ]; then
+            # Default to second-most recent supported Python version:
+            DEFAULT_PYTHON=$(ci-helper defaultpython)
+          fi
+
+          # Versions of Python to build conda packages for:
+          if [ -z "${CONDA_PYTHONS}" ]; then
+            # Default to all supported Python versions:
+            CONDA_PYTHONS=$(ci-helper pythons)
+          fi
+
+          # Env var for `cibuildwheel` specifying target Python versions:
+          if [ -z "${CIBW_BUILD}" ]; then
+            # default to all supported CPython versions:
+            CIBW_BUILD=$(ci-helper pythons --cibw)
+          fi
+
+          # Package name and version
+          if [ -z "${PKGNAME}" ]; then
+            # Default to package name from project metadata:
+            PKGNAME=$(ci-helper distinfo name .)
+          fi
+          if [ -z "${PKGVER}" ]; then
+            # Default to package version from project metadata:
+            PKGVER=$(ci-helper distinfo version .)
+          fi
+
+          # Whether the package is pure python
+          if [ -z "${PURE}" ]; then
+            # Default to whether the setuptools package declares no modules/libraries:
+            PURE=$(ci-helper distinfo is_pure .)
+          fi
+
+          # Whether the package requirements depend on platform or Python version:
+          if [ -z "${HAS_ENV_MARKERS}" ]; then
+            # Default to the presence of env markers in package metadata:
+            HAS_ENV_MARKERS=$(ci-helper distinfo has_env_markers .)
+          fi
+
+          # List of OSs we need to run the build job on and arguments to
+          # `setuptools-conda build`:
+          if [[ "${PURE}" == false || "${HAS_ENV_MARKERS}" == true ]]; then
+            BUILD_OS_LIST="${OS_LIST_ALL}"
+            CONDA_BUILD_ARGS="--pythons=${CONDA_PYTHONS}"
+          else
+            BUILD_OS_LIST="${OS_LIST_UBUNTU}"
+            CONDA_BUILD_ARGS="--noarch"
+          fi
+
+          # Release if a tag was pushed:
+          if [ "${{ contains(github.ref, '/tags') }}" == true ]; then
+            RELEASE=true
+          else
+            RELEASE=false
+          fi
+
+          # What types of package uploads are enabled:
+          if [ -z "${PYPI_UPLOAD}" ]; then
+            PYPI_UPLOAD=true
+          else
+            PYPI_UPLOAD=false
+          fi
+          if [ -z "${TESTPYPI_UPLOAD}" ]; then
+            TESTPYPI_UPLOAD=true
+          else
+            TESTPYPI_UPLOAD=false
+          fi
+          if [ -z "${ANACONDA_UPLOAD}" ]; then
+            ANACONDA_UPLOAD=true
+          else
+            ANACONDA_UPLOAD=false
+          fi
+          if [ -z "${TEST_ANACONDA_UPLOAD}" ]; then
+            TEST_ANACONDA_UPLOAD=true
+          else
+            TEST_ANACONDA_UPLOAD=false
+          fi
+
+          if [ "${{ github.repository }}" != "${RELEASE_REPO}" ]; then
+            echo "Workflow repo doesn't match ${RELEASE_REPO}, disabling package uploads"
+            PYPI_UPLOAD=false
+            TESTPYPI_UPLOAD=false
+            ANACONDA_UPLOAD=false
+            TEST_ANACONDA_UPLOAD=false
+          fi
+
+          # If Anaconda uploads enabled, check necessary username and token are
+          # available:
+          if [[ "${ANACONDA_UPLOAD}" == true || "${TEST_ANACONDA_UPLOAD}" == true ]]; then
+            if [ -z "${{ secrets.ANACONDA_API_TOKEN }}" ]; then
+              echo "Anaconda uploads enabled but ANACONDA_API_TOKEN secret not set"
+              exit 1
+            fi
+            if [ -z "${ANACONDA_USER}" ]; then
+              echo "Anaconda uploads enabled but ANACONDA_USER not set"
+              exit 1
+            fi
+          fi
+
+          # If enabled, upload releases to PyPI and Anaconda:
+          if [[ "${RELEASE}" == true && "${PYPI_UPLOAD}" == true ]]; then
+            PYPI_UPLOAD_THIS_RUN=true
+          else
+            PYPI_UPLOAD_THIS_RUN=false
+          fi
+          if [[ "${RELEASE}" == true && "${ANACONDA_UPLOAD}" == true ]]; then
+            ANACONDA_UPLOAD_THIS_RUN=true
+          else
+            ANACONDA_UPLOAD_THIS_RUN=false
+          fi
+
+          # If enabled, upload non-releases to Test PyPI and Anaconda test label:
+          if [[ "${RELEASE}" == false && "${TESTPYPI_UPLOAD}" == true ]]; then
+            TESTPYPI_UPLOAD_THIS_RUN=true
+          else
+            TESTPYPI_UPLOAD_THIS_RUN=false
+          fi
+          if [[ "${RELEASE}" == false && "${TEST_ANACONDA_UPLOAD}" == true ]]; then
+            TEST_ANACONDA_UPLOAD_THIS_RUN=true
+          else
+            TEST_ANACONDA_UPLOAD_THIS_RUN=false
+          fi
+
+          echo "DEFAULT_PYTHON=${DEFAULT_PYTHON}" >> "${GITHUB_OUTPUT}"
+          echo "CIBW_BUILD=${CIBW_BUILD}" >> "${GITHUB_OUTPUT}"
+          echo "PKGNAME=${PKGNAME}" >> "${GITHUB_OUTPUT}"
+          echo "PKGVER=${PKGVER}" >> "${GITHUB_OUTPUT}"
+          echo "PURE=${PURE}" >> "${GITHUB_OUTPUT}"
+          echo "ANACONDA_USER=${ANACONDA_USER}" >> "${GITHUB_OUTPUT}"
+          echo "CONDA_BUILD_ARGS=${CONDA_BUILD_ARGS}" >> "${GITHUB_OUTPUT}"
+          echo "BUILD_OS_LIST=${BUILD_OS_LIST}" >> "${GITHUB_OUTPUT}"
+          echo "RELEASE=${RELEASE}" >> "${GITHUB_OUTPUT}"
+          echo "TESTPYPI_UPLOAD_THIS_RUN=${TESTPYPI_UPLOAD_THIS_RUN}" >> "${GITHUB_OUTPUT}"
+          echo "PYPI_UPLOAD_THIS_RUN=${PYPI_UPLOAD_THIS_RUN}" >> "${GITHUB_OUTPUT}"
+          echo "TEST_ANACONDA_UPLOAD_THIS_RUN=${TEST_ANACONDA_UPLOAD_THIS_RUN}" >> "${GITHUB_OUTPUT}"
+          echo "ANACONDA_UPLOAD_THIS_RUN=${ANACONDA_UPLOAD_THIS_RUN}" >> "${GITHUB_OUTPUT}"
+
+          echo
+          echo "=========================="
+          echo "Workflow run configuration:"
+          echo "--------------------------"
+          cat "${GITHUB_OUTPUT}"
+          echo "=========================="
+          echo
+
+
+  build:
+    name: Build
+    runs-on: ${{ matrix.os }}
+    needs: configure
+    strategy:
+      matrix:
+        os: ${{ fromJSON(needs.configure.outputs.BUILD_OS_LIST) }}
+
+    env:
+      DEFAULT_PYTHON: ${{ needs.configure.outputs.DEFAULT_PYTHON }}
+      CIBW_BUILD: ${{ needs.configure.outputs.CIBW_BUILD }}
+      PURE: ${{ needs.configure.outputs.PURE }}
+      CONDA_BUILD_ARGS: ${{ needs.configure.outputs.CONDA_BUILD_ARGS }}
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v6
+        with:
+          fetch-depth: 0
+
+      - name: Ignore Tags for non-tag pushes
+        if: "!startsWith(github.ref, 'refs/tags/')"
+        run: git tag -d $(git tag --points-at HEAD)
+
+      - name: Install Python
+        uses: actions/setup-python@v6
+        with:
+          python-version: ${{ env.DEFAULT_PYTHON }}
+
+      - name: Install Python tools
+        run: python -m pip install --upgrade pip setuptools wheel build cibuildwheel
+
+      - name: Source distribution
+        if: strategy.job-index == 0
+        run: python -m build -s .
+
+      - name: Wheel distribution (pure)
+        if: env.PURE == 'true' && strategy.job-index == 0
+        run: python -m build -w .
+
+      - name: Wheel distribution (impure)
+        if: env.PURE == 'false'
+        run: cibuildwheel --output-dir dist
+
+      - name: Upload artifact
+        if: env.PURE == 'false' || strategy.job-index == 0
+        uses: actions/upload-artifact@v6
+        with:
+          name: dist-${{ matrix.os }}
+          path: ./dist
+          if-no-files-found: error
+
+      - name: Install Miniforge
+        uses: conda-incubator/setup-miniconda@v3
+        with:
+          miniforge-version: "latest"
+          auto-update-conda: true
+          conda-remove-defaults: true
+          auto-activate: true
+          activate-environment: ""
+
+      - name: Conda package
+        shell: bash -l {0}
+        run: |
+          if [ "${{ runner.os }}" == Windows ]; then
+            # Short path to minimise odds of hitting Windows max path length
+            CONDA_BUILD_ARGS+=" --croot ${{ runner.temp }}\cb"
+          fi
+          conda install -c labscript-suite setuptools-conda
+          setuptools-conda build $CONDA_BUILD_ARGS .
+
+      - name: Upload artifact
+        uses: actions/upload-artifact@v6
+        with:
+          name: conda_packages-${{ matrix.os }}
+          path: ./conda_packages
+          if-no-files-found: error
+
+
+  github-release:
+    name: Publish release (GitHub)
+    runs-on: ubuntu-latest
+    needs: [configure, build]
+    if: ${{ needs.configure.outputs.RELEASE == 'true' }}
+    permissions:
+      contents: write
+    env:
+      PKGNAME: ${{ needs.configure.outputs.PKGNAME }}
+      PKGVER: ${{ needs.configure.outputs.PKGVER }}
+
+    steps:
+      - name: Download Artifact
+        uses: actions/download-artifact@v8
+        with:
+          pattern: dist*
+          path: ./dist
+          merge-multiple: true
+
+      - name: Create GitHub release and upload release asset
+        uses: softprops/action-gh-release@v2
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          tag_name: ${{ github.event.ref }}
+          name: ${{ env.PKGNAME }} ${{ env.PKGVER }}
+          draft: true
+          prerelease: ${{ contains(github.event.ref, 'rc') }}
+          files: ./dist/*.tar.gz
+
+
+  testpypi-upload:
+    name: Publish on Test PyPI
+    runs-on: ubuntu-latest
+    needs: [configure, build]
+    if: ${{ needs.configure.outputs.TESTPYPI_UPLOAD_THIS_RUN == 'true' }}
+    env:
+      PKGNAME: ${{ needs.configure.outputs.PKGNAME }}
+      PKGVER: ${{ needs.configure.outputs.PKGVER }}
+    environment:
+      name: testpypi
+      url: https://test.pypi.org/project/${{ env.PKGNAME }}/${{ env.PKGVER }}
+    permissions:
+      id-token: write
+
+    steps:
+      - name: Download Artifact
+        uses: actions/download-artifact@v8
+        with:
+          pattern: dist*
+          path: ./dist
+          merge-multiple: true
+
+      - name: Publish on TestPyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          repository-url: https://test.pypi.org/legacy/
+          verbose: true
+          skip-existing: true
+
+
+  pypi-upload:
+    name: Publish on PyPI
+    runs-on: ubuntu-latest
+    needs: [configure, build]
+    if: ${{ needs.configure.outputs.PYPI_UPLOAD_THIS_RUN == 'true' }}
+    env:
+      PKGNAME: ${{ needs.configure.outputs.PKGNAME }}
+      PKGVER: ${{ needs.configure.outputs.PKGVER }}
+    environment:
+      name: pypi
+      url: https://pypi.org/project/${{ env.PKGNAME }}/${{ env.PKGVER }}
+    permissions:
+      id-token: write
+
+    steps:
+      - name: Download Artifact
+        uses: actions/download-artifact@v8
+        with:
+          pattern: dist*
+          path: ./dist
+          merge-multiple: true
+
+      - name: Publish on PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          verbose: true
+          skip-existing: true
+
+
+  test-anaconda-upload:
+    name: Publish on Anaconda (test label)
+    runs-on: ubuntu-latest
+    needs: [configure, build]
+    if: ${{ needs.configure.outputs.TEST_ANACONDA_UPLOAD_THIS_RUN == 'true' }}
+
+    steps:
+      - name: Download Artifact
+        uses: actions/download-artifact@v8
+        with:
+          pattern: conda_packages-*
+          path: ./conda_packages
+          merge-multiple: true
+
+      - name: Install Miniforge
+        uses: conda-incubator/setup-miniconda@v3
+        with:
+          miniforge-version: "latest"
+          auto-update-conda: true
+          conda-remove-defaults: true
+          auto-activate: true
+          activate-environment: ""
+
+      - name: Install Anaconda cloud client
+        shell: bash -l {0}
+        run: conda install anaconda-client
+
+      - name: Publish to Anaconda test label
+        shell: bash -l {0}
+        run: |
+          anaconda \
+            --token ${{ secrets.ANACONDA_API_TOKEN }} \
+            upload \
+            --skip-existing \
+            --user ${{ needs.configure.outputs.ANACONDA_USER }} \
+            --label test \
+            conda_packages/*/*
+
+
+  anaconda-upload:
+    name: Publish on Anaconda
+    runs-on: ubuntu-latest
+    needs: [configure, build]
+    if: ${{ needs.configure.outputs.ANACONDA_UPLOAD_THIS_RUN == 'true' }}
+
+    steps:
+      - name: Download Artifact
+        uses: actions/download-artifact@v8
+        with:
+          pattern: conda_packages-*
+          path: ./conda_packages
+          merge-multiple: true
+
+      - name: Install Miniforge
+        uses: conda-incubator/setup-miniconda@v3
+        with:
+          miniforge-version: "latest"
+          auto-update-conda: true
+          conda-remove-defaults: true
+          auto-activate: true
+          activate-environment: ""
+
+      - name: Install Anaconda cloud client
+        shell: bash -l {0}
+        run: conda install anaconda-client
+
+      - name: Publish to Anaconda main
+        shell: bash -l {0}
+        run: |
+          anaconda \
+            --token ${{ secrets.ANACONDA_API_TOKEN }} \
+            upload \
+            --skip-existing \
+            --user ${{ needs.configure.outputs.ANACONDA_USER }} \
+            conda_packages/*/*

zprocess-2.27.1/PKG-INFO

@@ -0,0 +1,39 @@
+Metadata-Version: 2.4
+Name: zprocess
+Version: 2.27.1
+Summary: A set of utilities for multiprocessing using zeromq
+Author-email: Christopher Billington <chrisjbillington@gmail.com>
+License-Expression: BSD-2-Clause
+Project-URL: Homepage, https://github.com/chrisjbillington/zprocess
+Project-URL: Documentation, https://github.com/chrisjbillington/zprocess
+Project-URL: Repository, https://github.com/chrisjbillington/zprocess
+Project-URL: Downloads, https://pypi.org/project/zprocess/
+Project-URL: Tracker, https://github.com/chrisjbillington/zprocess/issues
+Keywords: multiprocessing,IPC,zeromq
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: setuptools_scm
+Requires-Dist: pyzmq
+Requires-Dist: pywin32; sys_platform == "win32"
+Requires-Dist: windows-curses; sys_platform == "win32"
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-cov; extra == "test"
+Dynamic: license-file
+
+# zprocess
+
+A set of utilities for multiprocessing using
+zeromq. Includes process creation and management, output
+redirection, message passing, inter-process locks, logging,
+and a process-tree-wide event system.
+
+( 
+[view on pypi](https://pypi.python.org/pypi/zprocess/);
+[view on Github](https://github.com/chrisjbillington/zprocess)
+)
+
+   * Install `python setup.py install`.
+

{zprocess-2.26.1 → zprocess-2.27.1}/pyproject.toml

@@ -1,8 +1,9 @@
 [build-system]
-requires = ["setuptools", "wheel", "setuptools_scm"]
+requires = ["setuptools", "setuptools_scm"]
 build-backend = "setuptools.build_meta"
 
 [tool.setuptools_scm]
+version_scheme = "release-branch-semver"
 local_scheme = "no-local-version"
 
 [tool.setuptools.packages]
@@ -15,9 +16,9 @@ authors = [
     {name = "Christopher Billington", email = "chrisjbillington@gmail.com"},
 ]
 keywords = ["multiprocessing", "IPC", "zeromq"]
-license = {file = 'LICENSE.txt'}
+license = "BSD-2-Clause"
+license-files = ["LICENSE.txt"]
 classifiers = [
-    "License :: OSI Approved :: BSD License",
     "Programming Language :: Python :: 3 :: Only",
 ]
 requires-python = ">=3.8"

{zprocess-2.26.1 → zprocess-2.27.1}/tests/test_zlock_server.py

@@ -1,6 +1,7 @@
 import sys
 from pathlib import Path
 import time
+import threading
 import zmq
 import unittest
 
@@ -28,6 +29,8 @@ from zprocess.zlock.server import (
     ERR_TIMEOUT_INVALID,
     ERR_READ_ONLY_WRONG,
 )
+import zprocess.zlock as zlock
+from zprocess.zlock import ZLockClient
 import zprocess.zlock.server
 
 
@@ -679,8 +682,115 @@ class ImplementationUnitTests(unittest.TestCase):
         with self.assertRaises(NotWaiting):
             lock.give_up(b'client_foo')
 
+    def test_zlock_client_uses_instance_default_timeout(self):
+        class FakeSocket(object):
+            def __init__(self):
+                self.messages = []
+
+            def send_multipart(self, message, flags=0):
+                self.messages.append(message)
+
+            def recv(self):
+                return b'ok'
+
+            def close(self, linger=False):
+                pass
+
+        class FakePoller(object):
+            def poll(self, timeout):
+                return [object()]
+
+        client = ZLockClient(default_timeout=12.5)
+        client.local = threading.local()
+
+        def fake_new_socket(timeout=None):
+            client.local.sock = FakeSocket()
+            client.local.poller = FakePoller()
+            client.local.client_id = b'client'
+
+        client._new_socket = fake_new_socket
+        client.acquire('key_foo')
+
+        self.assertEqual(client.local.sock.messages[-1][3], b'12.5')
+
+    def test_set_client_thread_name_requires_default_client(self):
+        with monkeypatch(zlock, '_default_zlock_client', None):
+            with self.assertRaisesRegex(RuntimeError, 'ZLockClient'):
+                zlock.set_client_thread_name('worker')
+
+    def test_set_client_thread_name_delegates_to_default_client(self):
+        client = ZLockClient()
+        with monkeypatch(zlock, '_default_zlock_client', client):
+            zlock.set_client_thread_name('worker')
+
+        self.assertEqual(client.thread_name.name, 'worker')
+        self.assertIn(b'worker-', client.local.client_id)
+
+    def test_set_client_process_name_avoids_double_separator(self):
+        client = ZLockClient()
+        with monkeypatch(zlock, '_default_zlock_client', client):
+            zlock.set_client_process_name('worker')
+
+        process_identifier = client._make_client_id().split(':')[1]
+        self.assertTrue(process_identifier.startswith('worker-'))
+        self.assertNotIn('worker--', process_identifier)
+
 
 class OtherTests(unittest.TestCase):
+    def test_default_bind_address(self):
+        class FakeSocket(object):
+            def __init__(self):
+                self.logger = None
+
+            def bind_to_random_port(self, addr):
+                self.bound_addr = addr
+                return 7339
+
+            def bind(self, endpoint):
+                self.endpoint = endpoint
+
+            def close(self):
+                pass
+
+        class FakeContext(object):
+            def __init__(self):
+                self.sockets = []
+
+            def socket(self, *args, **kwargs):
+                sock = FakeSocket()
+                self.sockets.append(sock)
+                return sock
+
+        class FakePoller(object):
+            def register(self, *args, **kwargs):
+                pass
+
+        class FakeAllowInterrupt(object):
+            def __init__(self, handler):
+                self.handler = handler
+
+            def __enter__(self):
+                return self
+
+            def __exit__(self, *args):
+                return False
+
+        class FakeLogger(object):
+            def info(self, *args, **kwargs):
+                pass
+
+        fake_context = FakeContext()
+        server = ZMQLockServer(silent=True)
+
+        with monkeypatch(zprocess.zlock.server.SecureContext, 'instance', lambda *args, **kwargs: fake_context):
+            with monkeypatch(zprocess.zlock.server.zmq, 'Poller', FakePoller):
+                with monkeypatch(zprocess.zlock.server, 'allow_interrupt', FakeAllowInterrupt):
+                    with monkeypatch(zprocess.zlock.server, 'setup_logging', lambda *args, **kwargs: FakeLogger()):
+                        with monkeypatch(ZMQLockServer, '_mainloop', lambda self: None):
+                            server.run()
+
+        self.assertEqual(fake_context.sockets[0].bound_addr, 'tcp://*')
+
     def test_bind_to_port(self):
         # Run the server on a random port on localhost:
         import random