nocturne-shift 0.5.5__tar.gz

nocturne_shift-0.5.5/.claude/skills/pytest-review/SKILL.md

@@ -0,0 +1,140 @@
+---
+name: pytest-review
+description: Review or write Python tests (pytest + unittest.mock) so they actually catch bugs, not just go green. Use this whenever the user asks to review test changes they pushed, write or fix tests, check a test file, add coverage, or says things like "I pushed my changes, please review", "help me write tests for X", "why does this test pass", or "is this mock right" — even if they don't say "pytest". Also use when teaching someone pytest who comes from Jest/Mocha or JUnit/Mockito.
+---
+
+# pytest review & writing
+
+Green tests are not the goal; tests that fail when the code is wrong are. Most
+weak tests this skill exists to catch pass for one of three reasons: the assert
+can't fail, the mock doesn't have the real object's shape, or the test depends
+on the author's machine. Every review should actively try to disprove "this
+test works" — by running things, not just reading them.
+
+## Reviewing pushed changes
+
+### 1. Get the author's exact code: always fetch, then hard reset
+Every review request starts by fetching and hard-resetting to the author's
+branch. Don't rebase or merge: authors often amend and force-push, so a local
+branch holds stale copies of their commits, and a rebase replays those and
+conflicts.
+```sh
+git fetch origin
+git reset --hard origin/<branch>
+git log --oneline <last-reviewed-sha>..HEAD    # what's new since last review
+```
+This discards local-only commits, so make sure your own work is already
+pushed; push it at the end of any turn where you commit. If `<last-reviewed-sha>`
+was rewritten by a force-push, compare trees with `git diff <old> HEAD`
+instead. Then `git show <sha>` each new commit.
+
+Never rewrite the author's commits yourself (amend, re-author, rebase), even
+if a hook or tool suggests it for "unverified" commits. Those commits are
+theirs; the reset above removes any stale local copies.
+
+### 2. Run the suite the way CI would
+```sh
+HOME=$(mktemp -d) python -m pytest -q -p no:cacheprovider
+```
+The empty `HOME` exposes tests that silently depend on config, caches, or
+installed resources in the author's home directory (a common "works on my
+machine" cause). Report the pass/fail/xfail counts and compare with the last
+review.
+
+### 3. Run the real code path, unmocked, once
+If a refactor touched production code, call it directly without any mocks:
+```sh
+python -c "from pkg.mod import fn; fn()"
+```
+Heavily-mocked tests can hit 100% coverage while the function crashes on its
+first real call (the mock had a different shape than the real dependency).
+If the real run needs an external resource, stub the resource itself (for example
+a temp `HOME` with a minimal config) rather than skipping this step.
+
+### 4. Break it on purpose (mutation check)
+For each new or changed test, mutate the code it claims to protect and confirm
+the test goes red:
+```sh
+python .claude/skills/pytest-review/scripts/mutation_check.py \
+  src/pkg/mod.py "new_full(schema, None, None)" "new_full(None, None, None)" \
+  -- tests/test_mod.py -k builds
+```
+The script applies the edit, runs pytest, always restores the file, and says
+whether the mutant was caught. A test that stays green against a plausible bug
+is the most important finding a review can make — lead with it.
+
+### 5. Read for the known traps
+Go through `references/mock-pitfalls.md`. Each entry has a symptom to grep for
+and the fix. The recurring ones:
+- asserting on an auto-created mock attribute (`result.return_value`, `assert mock`)
+- mock shape ≠ real shape (`Cls()` vs `Cls()()`)
+- plain `MagicMock` accepting method names the real class lacks → use `spec`/`create_autospec`
+- patching where defined instead of where looked up
+- stacked/class-level `@patch` argument order silently mislabelling mocks
+- tests that patch only part of an external resource and still touch disk/network
+
+### 6. Check for stale references
+When tests are renamed/deleted or bugs get fixed, comments and docs rot:
+```sh
+git grep -n -E "<old test name>|<removed function>|BUG:|xfail" -- docs tests
+```
+Also check that fixed bugs lost their `xfail` markers and that any "this is a
+known bug" comments were updated.
+
+### 7. Write the review
+Use this structure; keep it scannable:
+
+```
+**Verdict:** one line — e.g. "Real fix, but test X can't fail."
+**What I ran:** suite result (and env), real-path result, mutation results.
+
+## ✅ Done well            (brief, specific — reinforce good habits)
+## [high] Title            — what's wrong, evidence (actual output), the fix as code,
+                             and the one-line lesson
+## [low] Title             — tidy-ups, grouped
+## Next                    — what to fix first / next exercise
+```
+
+Rules of thumb:
+- Every high finding carries evidence you produced (a traceback, a mutation
+  that stayed green) — not "this might fail".
+- Give the fix as a code snippet, and say *why* it works.
+- If a previous finding turns out wrong or overstated, say so and downgrade it.
+- If you track findings across rounds, show a small status table (✅ / ❌ / open).
+- Don't push fixes to the author's branch unless asked; when the user is
+  learning, offer to let them make the change.
+
+## Writing tests
+
+1. **State the promise first.** Before any assert, write down what the unit
+   promises ("returns what `new_full` built, with the looked-up schema"). One
+   assert per promise.
+2. **Fake at the edge, run the middle.** Mock network, clock, subprocesses, OS
+   services, UI toolkits. Don't mock your own logic; use `tmp_path` for real
+   files. Patch the outermost boundary you can (`requests.get`, not your own
+   `_fetch`) so more real code runs.
+3. **Match the real shape.** Mirror every call level the code uses
+   (`Cls.return_value.return_value` for `Cls()()`), or use `create_autospec`
+   so a wrong shape raises.
+4. **Assert identity/values, not truthiness.** `assert result is
+   mock.return_value`, `assert_called_once_with(...)`, `call_args.args[0]`.
+5. **Pin non-determinism.** Patch `datetime`, sort `os.scandir` results, never
+   depend on `HOME` or test order; reset module-level caches with
+   `monkeypatch.setattr(mod, "_cache", None)`.
+6. **Boundaries & branches.** Test both sides of each threshold (05:59/06:00)
+   and each `if`/`except` branch; use `@pytest.mark.parametrize` rather than
+   several cases in one test body (first failure hides the rest).
+7. **Known bugs → strict xfail.** Write the test for the *correct* behaviour
+   and mark it `@pytest.mark.xfail(strict=True, raises=<Exc>, reason="BUG: …")`.
+   `raises=` stops it "passing" as xfail for the wrong reason; `strict` makes
+   the eventual fix show up as XPASS so the marker gets removed. Verify each
+   xfail fails for the named reason with `pytest --runxfail`.
+8. **Then run steps 2–4 above on your own tests.**
+
+## Teaching mode
+
+If the user is learning (asks to be taught, mentions another stack), map each
+concept to what they know — see `references/pytest-rosetta.md` for pytest ↔
+Jest ↔ JUnit/Mockito equivalents — and explain the *why* at the point of use.
+Prefer letting them write the fix after the review; give a checklist with a
+self-verification command (`HOME=$(mktemp -d) …`, the mutation check).

nocturne_shift-0.5.5/.claude/skills/pytest-review/references/mock-pitfalls.md

@@ -0,0 +1,108 @@
+# unittest.mock pitfalls that make tests lie
+
+Each entry: **symptom** (what to look for), **why** it lies, **detect**, **fix**.
+Examples are real ones found while reviewing the night-shift repo.
+
+## Contents
+1. Asserting on auto-created attributes
+2. Mock shape ≠ real shape
+3. Loose MagicMock hides missing methods
+4. Patching where defined, not where looked up
+5. Stacked / class-level `@patch` argument order
+6. Partial patching still touches the machine
+7. Module-level caches leak between tests
+8. Smoke tests and tests that can't reach the code
+9. xfail that fails for the wrong reason
+
+---
+
+## 1. Asserting on auto-created attributes
+**Symptom:** `assert something.return_value`, `assert mock.foo`, `assert result`
+where `result` came from a mock.
+**Why:** A `MagicMock` creates any attribute on access and it is always truthy.
+`module._settings().return_value` is a brand-new MagicMock, so
+`assert settings` passes no matter what `_settings()` did.
+**Detect:** Mutation check — change the production call's arguments; the test stays green.
+**Fix:** Assert identity and arguments:
+```python
+settings = module._settings()
+assert settings is mock_new_full.return_value
+mock_new_full.assert_called_once_with(source.lookup.return_value, None, None)
+```
+
+## 2. Mock shape ≠ real shape
+**Symptom:** Production does `Settings()()` (wrapper whose `__call__` returns the
+real object) but the test sets `mock_cls.return_value = fake`.
+**Why:** The test exercises code you didn't write. Here the production line was
+`settings = Settings()` → `AttributeError: 'Settings' object has no attribute
+'get_value'` on the first real run, while the suite was green at 100% coverage.
+**Detect:** Run the real code path unmocked (SKILL.md step 3). `create_autospec(Settings)`
+would also raise `Mock object has no attribute 'get_value'`.
+**Fix:** Mirror each call level: `mock_cls.return_value.return_value = fake`,
+or use `create_autospec(RealClass)` so a wrong shape raises.
+
+## 3. Loose MagicMock hides missing methods
+**Symptom:** Code calls a method name the real API doesn't have
+(`settings.set_bool` — Gio only has `set_boolean`), or a check like
+`callable(proc)` that is always True for a MagicMock but False for a real `Popen`.
+**Why:** MagicMock accepts any name and is callable.
+**Fix:** `MagicMock(spec=Gio.Settings)` restricts attributes to the real class.
+For an *instance* use `create_autospec(Cls, instance=True)` — a spec taken from a
+class is itself callable, so `MagicMock(spec=Popen)` still passes `callable()`.
+If the test patches the very thing you want to spec (e.g. `subprocess.Popen`),
+capture the real one at import time: `REAL_POPEN = subprocess.Popen`.
+
+## 4. Patching where defined, not where looked up
+**Symptom:** `@patch("pkg.bin.fetch.Fetcher")` but the code under test did
+`from pkg.bin.fetch import Fetcher` in `pkg/__init__.py`.
+**Why:** `patch` rebinds one name in one namespace; the importer already holds
+its own reference. (Unlike `jest.mock`, which swaps the module in the registry.)
+**Fix:** Patch `<module that uses it>.<name it uses>` — e.g. `pkg.Fetcher`.
+For `import requests` + `requests.get(...)`, patch `pkg.mod.requests.get`.
+
+## 5. Stacked / class-level `@patch` argument order
+**Symptom:** A test class decorated with two `@patch`es whose methods name only
+one mock, or name them in the wrong order.
+**Why:** Decorators apply bottom-up → the **bottom** patch is the **first**
+argument after `self`. *Every* method receives all patch mocks positionally,
+regardless of parameter names; fixtures are injected by name only *after* them.
+So `def test_x(self, mock_a, mock_settings)` may bind `mock_settings` to the
+second patch, silently shadowing the fixture.
+**Detect:** Print the mocks' `_mock_name`, or assert on them.
+**Fix:** Name all patch args in bottom-up order, or prefer per-test `with patch(...)`.
+
+## 6. Partial patching still touches the machine
+**Symptom:** Only the last call in a chain is patched
+(`@patch("...Gio.Settings.new_full")`) while earlier calls
+(`Gio.SettingsSchemaSource.new_from_directory(~/.local/...)`) run for real.
+**Why:** Passes on the author's machine (resource installed), fails in CI/fresh
+clone: `GLib.Error: Failed to open file …/gschemas.compiled`.
+**Detect:** `HOME=$(mktemp -d) python -m pytest`.
+**Fix:** Patch at the seam that owns the resource (`_get_schema_source`, the
+module's `Gio`, `requests.get`), or inject paths so tests can pass `tmp_path`.
+
+## 7. Module-level caches leak between tests
+**Symptom:** A module global like `_schema_source = None` filled lazily.
+**Why:** The first test to run fills it; later tests reuse a real (or stale mock)
+object → order-dependent results.
+**Fix:** `monkeypatch.setattr(module, "_cache", None)` in the test/fixture
+(restored automatically). Check by running the file in a different order.
+
+## 8. Smoke tests and tests that can't reach the code
+**Symptom:** No assert; or an error injected into a mock that the chosen
+arguments never call (e.g. `side_effect = HTTPError` on `_get_location` while
+`use_geoclue=False`, and the HTTP method itself is mocked out).
+**Why:** Passes forever, proves nothing.
+**Fix:** Inject the failure where the real one originates
+(`response.raise_for_status.side_effect = HTTPError(...)`) and assert the
+observable outcome (`returns None`, `set_value.assert_not_called()`).
+
+## 9. xfail that fails for the wrong reason
+**Symptom:** `@pytest.mark.xfail` without `raises=`, or a mock set up so the test
+errors before reaching the buggy line.
+**Why:** Shows as the expected `x` even though it's not exercising the bug.
+**Detect:** `pytest --runxfail -q | grep "^E "` — each failure message should name the bug.
+**Fix:** Add `strict=True` and `raises=<ExpectedExc>`; fix the setup until the
+failure is the bug itself. When a strict xfail XPASSes, either the bug is fixed
+(remove the marker) or your hypothesis was wrong (turn it into a normal
+regression test).

nocturne_shift-0.5.5/.claude/skills/pytest-review/references/pytest-rosetta.md

@@ -0,0 +1,36 @@
+# pytest ↔ Jest ↔ JUnit 5 / Mockito
+
+Use when teaching someone who knows JS or Java testing.
+
+| Concept | pytest / unittest.mock | Jest | JUnit 5 + Mockito |
+|---|---|---|---|
+| Test discovery | `test_*.py`, `def test_*` | `*.test.js`, `test()` | `@Test` |
+| Grouping | `class Test*` (no `__init__`) | `describe()` | test class / `@Nested` |
+| Assert | `assert x == y` | `expect(x).toBe(y)` | `assertEquals(y, x)` |
+| Identity | `assert a is b` | `toBe` on objects | `assertSame` |
+| Expect exception | `with pytest.raises(E, match="re"):` | `expect(fn).toThrow()` | `assertThrows` |
+| Setup/teardown | fixture with `yield` | `beforeEach`/`afterEach` | `@BeforeEach`/`@AfterEach` |
+| Always-on setup | `@pytest.fixture(autouse=True)` | top-level `beforeEach` | base-class `@BeforeEach` |
+| Shared across files | `tests/conftest.py` | `setupFilesAfterEnv` | base class / extension |
+| Dependency injection | fixture name as parameter | — | constructor/extension injection |
+| Fake object | `MagicMock()` | `jest.fn()` | `mock(Foo.class)` |
+| Replace a dependency | `patch("mod.name")` | `jest.mock("mod")` | `@Mock` + `@InjectMocks` |
+| Stub return | `m.return_value = x` | `mockReturnValue(x)` | `when(...).thenReturn(x)` |
+| Stub sequence | `m.side_effect = [a, b]` | `mockReturnValueOnce` chain | `thenReturn(a, b)` |
+| Stub throw | `m.side_effect = Exc()` | `mockImplementation(() => {throw})` | `thenThrow` |
+| Stub with logic | `m.side_effect = fn` | `mockImplementation(fn)` | `thenAnswer` |
+| Verify call | `assert_called_once_with(a)` | `toHaveBeenCalledWith(a)` | `verify(m).f(a)` |
+| Capture arg | `m.call_args.args[0]` | `m.mock.calls[0][0]` | `ArgumentCaptor` |
+| Call order | `m.call_args_list[0] == call(...)` | `mock.calls[0]` | `InOrder` |
+| Type-safe mock | `spec=` / `create_autospec` | TS types | built in |
+| Table-driven | `@pytest.mark.parametrize` | `test.each` | `@ParameterizedTest` |
+| Known-broken | `xfail(strict=True)` | `test.failing` | — |
+| Temp dir | `tmp_path` | manual `mkdtemp` | `@TempDir` |
+| Capture stdout | `capsys` | spy on `console.log` | redirect `System.out` |
+| Temp global/env change | `monkeypatch` | manual restore | `@SetEnvironmentVariable` (ext) |
+| Fake clock | patch `mod.datetime` | `jest.useFakeTimers()` | inject `Clock` |
+
+Biggest conceptual difference to call out: `patch` replaces **one name in one
+namespace at runtime** (patch where it's looked up), whereas `jest.mock` swaps
+the whole module before import. And Python mocks are untyped — without `spec`
+they accept anything, which Java's compiler would have rejected.

nocturne_shift-0.5.5/.claude/skills/pytest-review/scripts/mutation_check.py

@@ -0,0 +1,69 @@
+#!/usr/bin/env python3
+"""Break the code on purpose and check that the tests notice.
+
+Usage:
+    mutation_check.py FILE OLD NEW [-- PYTEST_ARGS...]
+
+Replaces OLD (which must occur exactly once) with NEW in FILE, runs pytest (with
+PYTEST_ARGS, e.g. a test path and -k filter), then always restores FILE.
+
+Exit status: 0 if the mutant was caught (pytest failed), 1 if it survived
+(tests stayed green: they don't protect this code), 2 on usage errors or if pytest itself errors.
+"""
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+
+def main(argv):
+    if "--" in argv:
+        split = argv.index("--")
+        args, pytest_args = argv[:split], argv[split + 1 :]
+    else:
+        args, pytest_args = argv, []
+
+    if len(args) != 3:
+        print(__doc__, file=sys.stderr)
+        return 2
+
+    path, old, new = Path(args[0]), args[1], args[2]
+    original = path.read_text()
+    count = original.count(old)
+    if count != 1:
+        # A non-unique OLD would silently mutate whichever copy comes first,
+        # possibly in a different function than the one under review.
+        problem = "not found" if count == 0 else f"found {count} times"
+        print(f"'{old}' {problem} in {path}; include more context "
+              "(e.g. the preceding line, joined with a newline) so it "
+              "matches exactly once", file=sys.stderr)
+        return 2
+
+    env = {**os.environ, "PYTHONDONTWRITEBYTECODE": "1"}
+    # `-o addopts=` drops ini addopts (e.g. --cov) so plugins the project
+    # configures can't turn a run into a usage error.
+    cmd = [sys.executable, "-m", "pytest", "-q", "--no-header",
+           "-p", "no:cacheprovider", "-o", "addopts=", *pytest_args]
+    try:
+        path.write_text(original.replace(old, new, 1))
+        result = subprocess.run(cmd, capture_output=True, text=True, env=env)
+    finally:
+        path.write_text(original)
+
+    lines = [l for l in result.stdout.splitlines() if l.strip()]
+    print(f"mutant: {path}: {old!r} -> {new!r}")
+    print(f"pytest: {lines[-1] if lines else '(no output)'}")
+    # pytest exit codes: 0 all passed, 1 tests failed, >=2 error/usage/no tests.
+    if result.returncode == 0:
+        print("SURVIVED - tests stayed green; they don't protect this code")
+        return 1
+    if result.returncode == 1:
+        print("CAUGHT - tests failed as they should")
+        return 0
+    print(f"ERROR - pytest exited {result.returncode}; mutant not evaluated")
+    print(result.stdout[-2000:] + result.stderr[-2000:], file=sys.stderr)
+    return 2
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv[1:]))

nocturne_shift-0.5.5/.github/workflows/publish-pypi.yml

@@ -0,0 +1,119 @@
+name: Publish to PyPI
+
+# Run by hand: Actions tab -> "Publish to PyPI" -> Run workflow, on a commit
+# tagged cli-vX.Y.Z (nocturne-shift)
+# Uploads to PyPI are permanent, so:
+#   - only release versions are uploaded (no .devN / a / b / rc builds), and
+#   - the publish jobs use the `pypi` environment; give it required reviewers
+#     (Settings -> Environments) so every upload waits for your approval.
+# Logs in with PyPI Trusted Publishing: add a pending publisher on pypi.org for
+# nocturne-shift with repository christophermca/nocturne-shift, workflow
+# `publish-pypi.yml` and environment `pypi`.
+# gnome-night-shift is published from its own repo:
+# https://github.com/christophermca/gnome-night-shift
+on:
+  workflow_dispatch:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+        with:
+          fetch-depth: 0
+
+      - uses: actions/setup-python@v7
+        with:
+          python-version: "3.12"
+          cache: pip
+
+      # PyGObject builds from source on the runner; it needs these headers.
+      # libglib2.0-bin provides glib-compile-schemas for the schema tests.
+
+      - name: Install system libraries
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y libgirepository-2.0-dev libcairo2-dev pkg-config libglib2.0-bin
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          python -m pip install -e ".[test]"
+
+      - name: Run tests
+        run: python -m pytest
+
+  build:
+    needs: test
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+        with:
+          fetch-depth: 0
+
+      - uses: actions/setup-python@v7
+        with:
+          python-version: "3.12"
+          cache: pip
+
+      - name: Install system libraries
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y libgirepository-2.0-dev libcairo2-dev pkg-config libglib2.0-bin
+
+      - name: Build
+        run: |
+          python -m pip install --upgrade pip build twine
+          python -m build . --outdir dist/core            # nocturne-shift
+          python -m twine check --strict dist/*/*
+
+      # Install the freshly built wheel the way a user would, so a broken
+      # package or dependency fails here, not after the upload.
+      #
+      # Untagged commits build dev versions (0.4.4.dev3), which pip skips by
+      # default. Instead of --pre (pre-releases for *every* package, requests
+      # included), pin nocturne-shift to the exact version just built: a
+      # pin that names a pre-release allows it for that package only.
+      - name: Smoke-test the built wheels
+        run: |
+          for wheel in dist/*/*.whl; do
+            file=$(basename "$wheel")          # nocturne_shift-0.4.4.dev3-py3-none-any.whl
+            name=${file%%-*}                   # nocturne_shift
+            version=${file#*-}; version=${version%%-*}   # 0.4.4.dev3
+            echo "${name//_/-}==${version}"
+          done > /tmp/constraints.txt
+          cat /tmp/constraints.txt
+          python -m venv /tmp/smoke
+          /tmp/smoke/bin/pip install --constraint /tmp/constraints.txt \
+            --find-links dist/core nocturne-shift
+          /tmp/smoke/bin/nocturne-shift --version
+
+      # PyPI is permanent: only upload versions built from a release tag.
+      - name: Refuse dev / pre-release builds
+        run: |
+          if ls dist/core/*.whl | grep -E "\.dev[0-9]+|a[0-9]+-|b[0-9]+-|rc[0-9]+-"; then
+            echo "::error::Not a release build. Tag the commit (cli-vX.Y.Z) and run from it."
+            exit 1
+          fi
+          echo "Release versions only:" && ls dist/core/*.whl
+
+      - uses: actions/upload-artifact@v7
+        with:
+          name: core-dist
+          path: dist/core/
+
+  publish-core:
+    needs: build
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/download-artifact@v8
+        with:
+          name: core-dist
+          path: dist/
+      - uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          # PyPI refuses a version twice; skip instead of failing.
+          skip-existing: true

nocturne_shift-0.5.5/.github/workflows/publish-testpypi.yml

@@ -0,0 +1,106 @@
+name: Publish to TestPyPI
+
+# Run by hand: Actions tab -> "Publish to TestPyPI" -> Run workflow.
+# Logs in with Trusted Publishing: the nocturne-shift project on test.pypi.org
+# needs a publisher with repository christophermca/nocturne-shift, workflow
+# `publish-testpypi.yml` and environment `test-pypi`.
+# gnome-night-shift is published from its own repo:
+# https://github.com/christophermca/gnome-night-shift
+on:
+  workflow_dispatch:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+        with:
+          fetch-depth: 0
+
+      - uses: actions/setup-python@v7
+        with:
+          python-version: "3.12"
+          cache: pip
+
+      # PyGObject builds from source on the runner; it needs these headers.
+      # libglib2.0-bin provides glib-compile-schemas for the schema tests.
+
+      - name: Install system libraries
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y libgirepository-2.0-dev libcairo2-dev pkg-config libglib2.0-bin
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          python -m pip install -e ".[test]"
+
+      - name: Run tests
+        run: python -m pytest
+
+  build:
+    needs: test
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+        with:
+          fetch-depth: 0
+
+      - uses: actions/setup-python@v7
+        with:
+          python-version: "3.12"
+          cache: pip
+
+      - name: Install system libraries
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y libgirepository-2.0-dev libcairo2-dev pkg-config libglib2.0-bin
+
+      - name: Build
+        run: |
+          python -m pip install --upgrade pip build twine
+          python -m build . --outdir dist/core            # nocturne-shift
+          python -m twine check --strict dist/*/*
+
+      # Install the freshly built wheel the way a user would, so a broken
+      # package or dependency fails here, not after the upload.
+      #
+      # Untagged commits build dev versions (0.4.4.dev3), which pip skips by
+      # default. Instead of --pre (pre-releases for *every* package, requests
+      # included), pin nocturne-shift to the exact version just built: a
+      # pin that names a pre-release allows it for that package only.
+      - name: Smoke-test the built wheels
+        run: |
+          for wheel in dist/*/*.whl; do
+            file=$(basename "$wheel")          # nocturne_shift-0.4.4.dev3-py3-none-any.whl
+            name=${file%%-*}                   # nocturne_shift
+            version=${file#*-}; version=${version%%-*}   # 0.4.4.dev3
+            echo "${name//_/-}==${version}"
+          done > /tmp/constraints.txt
+          cat /tmp/constraints.txt
+          python -m venv /tmp/smoke
+          /tmp/smoke/bin/pip install --constraint /tmp/constraints.txt \
+            --find-links dist/core nocturne-shift
+          /tmp/smoke/bin/nocturne-shift --version
+
+      - uses: actions/upload-artifact@v7
+        with:
+          name: core-dist
+          path: dist/core/
+
+  publish-core:
+    needs: build
+    runs-on: ubuntu-latest
+    environment: test-pypi
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/download-artifact@v8
+        with:
+          name: core-dist
+          path: dist/
+      - uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          repository-url: https://test.pypi.org/legacy/
+          # TestPyPI refuses a version twice; skip instead of failing.
+          skip-existing: true

nocturne_shift-0.5.5/.github/workflows/test.yml

@@ -0,0 +1,41 @@
+name: Tests
+
+on:
+  push:
+  pull_request:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.11", "3.10"]
+
+    steps:
+      - name: Check out repository
+        uses: actions/checkout@v7
+        with:
+          fetch-depth: 0
+
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v7
+        with:
+          python-version: ${{ matrix.python-version }}
+          cache: pip
+
+      # PyGObject builds from source on the runner; it needs these headers.
+      # libglib2.0-bin provides glib-compile-schemas for the schema tests.
+      - name: Install system libraries
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y libgirepository-2.0-dev libcairo2-dev pkg-config libglib2.0-bin
+
+      # [test] brings pytest, pytest-cov (pytest.ini uses --cov) and freezegun
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          python -m pip install -e ".[test]"
+
+      - name: Run tests
+        run: python -m pytest