morphata 2.0.0__tar.gz → 2.0.2__tar.gz

morphata-2.0.2/.claude/settings.local.json

@@ -0,0 +1,29 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(mypy *)",
+      "Bash(python -m mypy *)",
+      "Bash(python3 -m mypy *)",
+      "Bash(pytest *)",
+      "Bash(python -m pytest *)",
+      "Bash(python3 -m pytest *)",
+      "Bash(just lint *)",
+      "Bash(just test *)",
+      "Bash(rg *)",
+      "Bash(uv run pytest *)",
+      "Bash(uv run mypy *)",
+      "Bash(.venv/bin/python -m pytest *)",
+      "Skill(superpowers:writing-plans)",
+      "Skill(superpowers:subagent-driven-development)",
+      "Bash(grep -v \"AssertionError\\\\|Traceback\\\\|File \\\\|^\\\\s*$\")",
+      "Skill(superpowers:brainstorming)",
+      "Bash(jj log *)",
+      "Bash(jj st *)",
+      "Bash(jj diff *)",
+      "Skill(superpowers:requesting-code-review)",
+      "Bash(timeout 15 python -c ' *)",
+      "Read(//tmp/**)",
+      "Bash(echo \"exit: $?\")"
+    ]
+  }
+}

{morphata-2.0.0 → morphata-2.0.2}/.envrc

@@ -12,15 +12,15 @@ if [[ -z "${DEVJAIL:-}" ]] && nvidia_smi="$(type -p "nvidia-smi")" && [[ -n "$nv
   if [[ -n "${cuda_major_version:-}" ]]; then
     info "Detected CUDA version: $cuda_major_version"
     export CUDA_VERSION="$cuda_major_version"
+    PIXI_ENV="cu$CUDA_VERSION"
   fi
 else
   info "Did not detect nvidia-smi, using non-GPU environment"
+  PIXI_ENV="default"
 fi
+export PIXI_ENV
 
 dotenv_if_exists
 
-if [[ -z "${DEVJAIL:-}" ]] || [[ ! -e ".venv/bin/activate" ]]; then
-  uvx --from rust-just just dev
-fi
-source ./.venv/bin/activate
-watch_file pyproject.toml
+watch_file pixi.lock
+eval "$(pixi shell-hook -e "$PIXI_ENV")"

morphata-2.0.2/.gitattributes

@@ -0,0 +1,5 @@
+# GitHub syntax highlighting
+pixi.lock linguist-language=YAML
+
+# SCM syntax highlighting & preventing 3-way merges
+pixi.lock merge=binary linguist-language=YAML linguist-generated=true -diff

{morphata-2.0.0 → morphata-2.0.2}/.gitignore

@@ -257,3 +257,6 @@ $RECYCLE.BIN/
 *.lnk
 
 # End of https://www.toptal.com/developers/gitignore/api/macos,windows,linux
+# pixi environments
+.pixi/*
+!.pixi/config.toml

{morphata-2.0.0 → morphata-2.0.2}/AGENTS.md

@@ -4,6 +4,14 @@
 It packages structural automaton representations together with semiring-valued
 *operators* that turn an automaton into a computable interpretation.
 
+## Development Environment
+
+The development shell already has the project virtual environment activated,
+so `pytest`, `mypy`, `ruff`, `sphinx-build`, etc. are on `PATH` directly.
+**Do not** prefix commands with `uv run`, `pixi run`, `poetry run`, or similar.
+Just invoke the tool. If a tool is missing, stop and tell the user rather than
+trying to bootstrap or reinstall the environment.
+
 ## Core Architecture
 
 ### IR layer (`morphata.automaton`, `morphata.alphabet`, `morphata.acceptance`)
@@ -85,6 +93,21 @@ delta - the transition consumes the labelled graph eagerly, so STREL
 automata are not symbolically liftable.  Operators: Reach, Escape,
 Somewhere, Everywhere.  Boolean-only.
 
+**`morphata.logic.sere.sere_to_automaton(expr)`** : SERE -> alternating
+finite automaton.  Supports ``Concat``, ``Fusion``, ``Repeat`` (bounded
+and unbounded), ``Inter``, ``Alt``, and Boolean leaves over AP.
+Acceptance is always ``Finite``; the accepting-state set is exactly
+the *nullable* states (those that match the empty word).
+
+**`morphata.logic.psl.psl_to_automaton(phi, *, finite=False)`** : PSL ->
+alternating automaton.  Wraps pure-LTL subformulas in an internal
+``_LTL`` tag and dispatches to the LTL expansion rule; closure
+operators (``{r}!``, ``{r}``, ``!{r}``, ``{r}<>-> f``, ``{r}[]-> f``)
+become their own tagged states with SERE-step expansion.  Suffix
+implications follow Spot's overlapping semantics: the last symbol of
+``r`` and the first position of ``f`` coincide.  ``finite=True`` ->
+``Finite`` acceptance (PSLf); ``finite=False`` -> ``Buchi``.
+
 Hand-written automata are built with ``AutomatonBuilder``; the package
 has no separate ``constructions`` namespace.
 
@@ -211,6 +234,18 @@ is backend-agnostic via `backend=`.
   sets of transitions. The HOA parser ingests ``{n}`` markers from
   ``State:`` declarations; per-edge ``{n}`` markers are ignored. Convert
   transition-based HOA files to state-based form before loading them.
+- ``psl_to_automaton`` requires the continuation of any
+  ``SuffixImpliesExist`` / ``SuffixImpliesUniv`` to be a pure-LTL
+  formula in v1.  Nested PSL closures inside a suffix-implication
+  continuation raise ``NotImplementedError``.  Likewise, LTL temporal
+  operators wrapping a PSL closure at the top level
+  (e.g. ``Always(StrongClosure(r))``) are not yet decomposed; lift the
+  PSL fragment out of the LTL temporal operator before calling.
+- The PSL Buchi acceptance classification is the natural per-tag rule
+  (strong-closure non-accepting, weak-closure accepting, etc.).  It has
+  not been cross-checked against a published reference for every
+  combination of operators; consult ``docs/superpowers/specs/`` before
+  relying on omega-language semantics in production.
 
 ## Testing
 
@@ -334,6 +369,10 @@ matrix_product = algebraic.matmul(arr1, arr2)
 - `src/morphata/builder.py` : ``AutomatonBuilder``.
 - `src/morphata/acceptance.py` : expression-based acceptance conditions.
 - `src/morphata/logic/ltl.py` : LTL/LTLf -> AFA conversion.
+- `src/morphata/logic/sere.py` : SERE -> AFA conversion.
+- `src/morphata/logic/psl.py` : PSL -> AFA conversion.
+- `src/morphata/logic/_common.py` : shared BDD scratch-space setup used
+  by all three logic converters.
 - `src/morphata/logic/strel.py` : STREL automaton (``Step`` delta).
 - `src/morphata/hoa/` : HOA v1 parser, exporter, grammar.
 - `src/morphata/operators/matrix.py` : ``MatrixOperator``.

{morphata-2.0.0 → morphata-2.0.2}/CHANGELOG.md

@@ -1,6 +1,118 @@
 # Changelog
 
-## 2.0.0 — [Unreleased]
+## 2.0.2 — 2026-05-27
+
+### Added
+
+- The rest of the SERE surface that needed real work, rather than a desugaring rule:
+  non-length-matching intersection
+  (`NLMInter`, the `&` operator), `Complement` (`~`), and `FirstMatch`.
+  NLM intersection is handled by a local rewrite in the expansion polynomial;
+  complement dualises the polynomial and gets a small BFS-loop special case
+  so the state space stays compact.
+  `GotoRepeat`, `EqualRepeat`,
+  and bounded `FusionRepeat` desugar through `logic_asts.spec.Expr.expand`.
+  Unbounded `FusionRepeat[:*i..]` deliberately raises `NotImplementedError` —
+  I don't have a clean expansion for it yet.
+- Benchmarking script for SERE NLM intersection, so I can see when I
+  break the perf curve.
+
+### Changed
+
+- `morphata.logic.psl` dropped a layer of in-tree wrappers
+  and leans on `logic_asts` types directly now
+  that the upstream package carries the extended SERE surface I needed.
+  Less code, fewer places for the two sides to disagree.
+
+### Miscellaneous
+
+- The README is linked from `pyproject.toml`, so it actually shows up
+  on PyPI.
+
+## 2.0.1 — 2026-05-24
+
+The point release that delivers the SERE
+and PSL frontends originally promised alongside 2.0,
+plus the perf work that made the symbolic pipeline actually finish on formulas of
+interest.
+
+### Added
+
+- `morphata.logic.sere.sere_to_automaton(formula)` —
+  converts a SERE expression to an alternating finite automaton.
+  Supports `Concat`, `Fusion`, `Alt`, `Inter` (length-matching), `Repeat`
+  (bounded and unbounded),
+  and Boolean leaves (`Literal`, `Variable`, `Not`, `And`, `Or`).
+- `morphata.logic.psl.psl_to_automaton(phi, *, finite=False)` —
+  converts a PSL expression to an alternating automaton,
+  with `Finite` acceptance for PSLf (`finite=True`) and `Büchi` acceptance
+  for full PSL (`finite=False`).
+  Supports the strong / weak / negated-strong closure operators
+  and existential / universal suffix implication.
+  Suffix implications follow Spot's overlapping semantics:
+  the last symbol matched by the SERE prefix is shared with the first position at
+  which the continuation is evaluated.
+
+### Changed
+
+- `morphata.logic.ltl` factored its per-call BDD scratch-space construction into a
+  shared helper `morphata.logic._common.make_logic_context`, reused by the SERE and PSL
+  converters.
+  Two LTL helpers (`_aut_symbolic_expansion`, `_empty_trace_value`) were renamed to
+  `ltl_symbolic_expansion` / `ltl_empty_trace_value` so PSL can delegate to them for
+  pure-LTL subformulas.
+- Moved off `uv` and onto Pixi. `uv`'s handling of CUDA packages and
+  the way it churns the lockfile weren't working for me; Pixi does.
+
+### Fixed
+
+- New BDD constructions in `morphata.logic` take an explicit manager parameter instead
+  of silently spinning up their own.
+- `bdd_to_boolexpr` in `morphata.symbolic.bdd` was silently folding `~x`
+  and `x` together because the CUDD complement-edge flag on the current node wasn't
+  being respected on the recursive walk.
+  Caught while rewriting `ltl_to_automaton`; fixed there.
+
+### Performance
+
+- `ltl_to_automaton` no longer iterates `2^|AP|` input symbols per AFA state.
+  The closure BFS keeps APs symbolic, builds an expansion polynomial with tagged atoms
+  (one tag for guard atoms, one for successor states),
+  compiles it to a per-call BDD,
+  and partitions AP-space by distinct state cofactors via the new
+  `mgr_partition_ap_by_state_residual` helper.
+  Per-AFA-state cost drops from `O(2^|AP|)` to `O(distinct successor classes)`,
+  and AP variables that don't affect a given cofactor get pruned.
+  A depth-15 sequential conjunction `F(a_0) & X(F(a_1) & X(...))`
+  that used to take ~330s and OOM at depth 20 now builds in ~0.02s.
+  The remaining wall-clock on those formulas lives in `nfa_from_afa`,
+  which is intrinsic `2^N` in macro state count.
+- `SymbolicAutomaton.to_min_dfa()` is tractable on formulas with non-trivial `|AP|`
+  (`~5+` for monotone conjunctions, `~10+` for sequential), where it used to hang.
+  Three pieces: prime-implicant DFS (`mgr_minimal_pos_satisfying_subsets`) replaces the
+  old `2^(2^|AP|)` BDD-evaluation pass in `_nfa_macro_step` after dealternation;
+  symbolic AP-space partition helpers (`mgr_partition_ap_by_classifiers` and
+  `mgr_partition_ap_by_state_residual`) replace explicit `2^|AP|` minterm enumeration in
+  `determinize` and `nfa_from_afa`; and `_extract_dfa_target` parses the single
+  state-variable name directly instead of linear-scanning every state in the manager,
+  removing an `O(num_states^2)` per-refinement-round cost inside `minimize()`.
+
+Sadly (but not really sadly),
+these performance fixes make the BDD manager a viral argument in `morphata.logic`,
+but it isn't too bad as it is optional,
+and the `morphata.logic.*_to_automaton` functions will automatically create a
+short-lived manager for these things.
+
+### Known Limitations
+
+- `psl_to_automaton` does not yet decompose LTL temporal operators
+  that wrap PSL closures at the top level (e.g. `Always(StrongClosure(r))`).
+  Lift the PSL fragment out of the surrounding LTL temporal operator before calling.
+- The continuation of a `SuffixImpliesExist` / `SuffixImpliesUniv`
+  must be a pure-LTL formula; nested PSL closures inside a
+  continuation raise `NotImplementedError`.
+
+## 2.0.0 — 2026-05-23
 
 The major version bump folds the old `automatix` package into `morphata`
 and replaces the constellation automata classes with a single typed intermediate

{morphata-2.0.0 → morphata-2.0.2}/CONTRIBUTING.md

@@ -6,24 +6,30 @@ The `justfile` defines a set of build, lint, and test commands, which can direct
 run as below:
 
 
+The examples below assume the project virtual environment is activated (either
+via `direnv` and `.envrc`, or by sourcing `.venv/bin/activate` manually). With
+the venv active the tools are on `PATH` directly; no `uv run` prefix is needed.
+If you'd rather not activate, prefix each command with `uv run --dev --frozen`
+(or use the `just` recipes, which handle this for you).
+
 **Testing** :
 ```bash
 # Run all tests (uses --lf for last-failed)
 just test
 # OR
-uv run --dev --frozen pytest --lf
+pytest --lf
 
 # Run all tests verbosely without --lf
-uv run --dev --frozen pytest -v
+pytest -v
 
 # Run a single test file
-uv run --dev --frozen pytest tests/test_weights.py -v
+pytest tests/test_alphabet.py -v
 
 # Run a single test function
-uv run --dev --frozen pytest tests/test_weights.py::TestWeightFunctionBasics::test_constant_weight_function -v
+pytest tests/test_alphabet.py::TestBooleanAlphabet::test_powerset_alphabet -v
 
 # Run with coverage
-uv run --dev --frozen pytest --cov=morphata --cov-report=term
+pytest --cov=morphata --cov-report=term
 ```
 
 **Linting and Formatting** :
@@ -31,8 +37,8 @@ uv run --dev --frozen pytest --cov=morphata --cov-report=term
 # Format and lint (fixes issues automatically)
 just fmt
 # OR
-uv run --frozen ruff format
-uv run --frozen ruff check --output-format concise --fix --exit-non-zero-on-fix
+ruff format
+ruff check --output-format concise --fix --exit-non-zero-on-fix
 
 # Format + type check
 just lint
@@ -44,9 +50,9 @@ just lint
 just type-check
 
 # Run specific type checkers
-uv run --frozen mypy --strict
-uv run --frozen ty check --output-format concise
-uv run --frozen pyrefly check --output-format min-text
+mypy --strict
+ty check --output-format concise
+pyrefly check --output-format min-text
 ```
 
 **Development Setup** :

{morphata-2.0.0 → morphata-2.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: morphata
-Version: 2.0.0
+Version: 2.0.2
 Summary: Representation theory for automata, made practical.
 Project-URL: Documentation, https://docs.anandb.dev/morphata
 Project-URL: Repository, https://git.anandb.dev/morphata.git
@@ -16,7 +16,7 @@ Requires-Dist: attrs>=25.4.0
 Requires-Dist: dd>=0.6.0
 Requires-Dist: jaxtyping>=0.3
 Requires-Dist: lark>=1.3.1
-Requires-Dist: logic-asts>=1.4.1
+Requires-Dist: logic-asts>=1.6.2
 Requires-Dist: networkx
 Requires-Dist: numpy
 Requires-Dist: types-networkx

morphata-2.0.2/bench/README.md

@@ -0,0 +1,28 @@
+# morphata bench
+
+Opt-in benchmark suite. Not collected by the default `pytest`
+invocation.
+
+## Running
+
+    pytest bench/ -v
+
+To get pytest-benchmark's tabular wall-time output:
+
+    pytest bench/ -v --benchmark-columns=mean,median,min,max,rounds
+
+## Suites
+
+- `test_sere_nlm_perf.py` -- NLM-intersection state-space blowup.
+  Cases: `NLMInter(a0..a_{n-1})` for n in 2..6, `NLMInter(a_i;b_i)`
+  for n in 2..4, plus length-matching `Inter` baselines.
+
+## Recording results
+
+After running, paste the resulting tables (state count + wall time)
+into the spec doc at:
+`docs/superpowers/specs/2026-05-26-psl-refactor-and-nlm-perf-design.md`
+
+The Phase 2 fix (memoization / pre-pass canonicalization / first-class
+`_NLMInter` state) is chosen based on the numbers; the choice is
+recorded as a follow-up plan.

morphata-2.0.2/bench/conftest.py

@@ -0,0 +1,53 @@
+"""pytest fixtures for the morphata bench suite.
+
+The bench/ tree is opt-in: invoke with `pytest bench/` (or
+`pytest bench/test_sere_nlm_perf.py`). It is not collected by the
+default `pytest` invocation.
+"""
+
+from __future__ import annotations
+
+import gc
+from collections.abc import Iterator
+
+import pytest
+
+from morphata.logic.sere import _expansion_call_counter
+from morphata.symbolic.bdd import Manager, make_manager
+
+
+@pytest.fixture
+def bench_mgr() -> Iterator[Manager]:
+    """Shared BDD manager scoped to one bench test (= many benchmark rounds).
+
+    Bench tests pass this manager to ``sere_to_automaton(..., manager=mgr)``
+    so the per-call ``make_manager()`` path is skipped. That path leaks
+    ~12 MB of CUDD-internal state per call, which compounds across the
+    ~100-1000 rounds pytest-benchmark runs per test and exhausts host
+    RAM. Sharing the manager keeps RSS flat.
+    """
+    manager = make_manager()
+    try:
+        yield manager
+    finally:
+        gc.collect()
+
+
+@pytest.fixture
+def expansion_calls() -> Iterator[list[int]]:
+    """Activate the expansion-call counter for the duration of one test.
+
+    Yields a single-element list whose entry is filled in by the test
+    with the final call count snapshot (`current_expansion_call_count()`).
+    """
+    token = _expansion_call_counter.set(0)
+    try:
+        yield [0]
+    finally:
+        _expansion_call_counter.reset(token)
+
+
+def current_expansion_call_count() -> int:
+    """Read the current expansion-call counter value (0 if inactive)."""
+    val = _expansion_call_counter.get()
+    return val if val is not None else 0

morphata-2.0.2/bench/test_sere_nlm_perf.py

@@ -0,0 +1,84 @@
+"""Benchmark suite for SERE NLMInter state-space behaviour.
+
+Run with: ``pytest bench/test_sere_nlm_perf.py -v``
+
+Records state count, expansion-call count, and wall time for
+NLM-intersection of n branches, plus length-matching Inter as a
+baseline.
+
+History note: the original spec hypothesised an exponential blowup
+in branch count for ``NLMInter``. Direct measurement (see the spec's
+"Phase 1 Benchmark Results" section) showed no such blowup -- state
+count stays at 3 for arbitrarily many AP-literal branches and grows
+linearly (2n+3) for length-2-concat branches. The bench is retained
+as a regression guard.
+
+A separate finding from this investigation: ``make_manager()`` leaks
+~12 MB of CUDD-internal state per call, so the bench passes a single
+``bench_mgr`` fixture into ``sere_to_automaton(..., manager=mgr)``
+to keep RSS flat across the ~100-1000 rounds pytest-benchmark runs
+per test. Without that, repeated calls compound to GiB-scale RSS and
+hang the host.
+"""
+
+from __future__ import annotations
+
+import logic_asts as logic
+import logic_asts.sere as sere
+import pytest
+from pytest_benchmark.fixture import BenchmarkFixture as Benchmark
+
+from morphata.logic.sere import sere_to_automaton
+from morphata.symbolic.bdd import Manager
+
+from .conftest import current_expansion_call_count
+
+
+def _nlm_of_aps(n: int) -> logic.Expr:
+    return sere.NLMInter(tuple(sere.Variable(f"a{i}") for i in range(n)))
+
+
+def _lm_of_aps(n: int) -> logic.Expr:
+    return sere.Inter(tuple(sere.Variable(f"a{i}") for i in range(n)))
+
+
+def _nlm_of_concats(n: int) -> logic.Expr:
+    return sere.NLMInter(tuple(sere.Concat((sere.Variable(f"a{i}"), sere.Variable(f"b{i}"))) for i in range(n)))
+
+
+def _run_and_measure(formula: logic.Expr, mgr: Manager) -> tuple[int, int]:
+    """Return ``(state_count, expansion_call_count)``."""
+    aut = sere_to_automaton(formula, manager=mgr)
+    states = aut.states
+    n_states = len(states) if states is not None and not callable(states) else 0
+    return (n_states, current_expansion_call_count())
+
+
+@pytest.mark.timeout(10)
+@pytest.mark.parametrize("n", list(range(2, 10)))
+def test_bench_nlm_of_aps(benchmark: Benchmark, expansion_calls: list[int], bench_mgr: Manager, n: int) -> None:
+    formula = _nlm_of_aps(n)
+    result = benchmark(_run_and_measure, formula, bench_mgr)
+    state_count, call_count = result
+    expansion_calls[0] = call_count
+    print(f"\nNLMInter(a0..a{n - 1}): states={state_count} expansion_calls={call_count}")
+
+
+@pytest.mark.timeout(10)
+@pytest.mark.parametrize("n", list(range(2, 10)))
+def test_bench_lm_of_aps_baseline(benchmark: Benchmark, expansion_calls: list[int], bench_mgr: Manager, n: int) -> None:
+    formula = _lm_of_aps(n)
+    result = benchmark(_run_and_measure, formula, bench_mgr)
+    state_count, call_count = result
+    expansion_calls[0] = call_count
+    print(f"\nInter(a0..a{n - 1}): states={state_count} expansion_calls={call_count}")
+
+
+@pytest.mark.timeout(10)
+@pytest.mark.parametrize("n", list(range(2, 10)))
+def test_bench_nlm_of_concats(benchmark: Benchmark, expansion_calls: list[int], bench_mgr: Manager, n: int) -> None:
+    formula = _nlm_of_concats(n)
+    result = benchmark(_run_and_measure, formula, bench_mgr)
+    state_count, call_count = result
+    expansion_calls[0] = call_count
+    print(f"\nNLMInter(a_i;b_i) n={n}: states={state_count} expansion_calls={call_count}")

morphata-2.0.2/ci/make-release

@@ -0,0 +1,131 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Usage ------------------------------------------------------------------
+usage() {
+  cat <<EOF
+Usage: $(basename "$0") <bump>
+
+  bump      Version bump kind passed to 'uv version --bump'
+            (patch, minor, major, etc.)
+
+Examples:
+  $(basename "$0") patch
+  $(basename "$0") minor
+EOF
+  exit 1
+}
+
+if [[ $# -ne 1 ]]; then
+  usage
+fi
+
+PROJECT_DIR="$(cd "$(dirname "$(realpath "${BASH_SOURCE[0]}")")/.." && pwd)"
+cd "$PROJECT_DIR"
+
+BUMP="$1"
+
+# Helpers ----------------------------------------------------------------
+is_jj() { [[ -d "$PROJECT_DIR/.jj" ]]; }
+
+check_clean() {
+  if is_jj; then
+    if [[ -n "$(jj diff --summary 2>/dev/null)" ]]; then
+      echo "error: working copy is not clean (jj diff shows changes)" >&2
+      exit 1
+    fi
+  else
+    if [[ -n "$(git status --porcelain)" ]]; then
+      echo "error: working copy is not clean (git status shows changes)" >&2
+      exit 1
+    fi
+  fi
+}
+
+# Lint & type-check
+echo "==> Running linters and type checkers..."
+just lint
+
+# Ensure working copy is clean
+echo -n "==> Checking working copy is clean... "
+check_clean
+echo "    OK"
+
+# CHANGELOG.md is hand-authored under an `## Unreleased` heading; this
+# script promotes that heading to the new version and dates it.
+# Make sure that the Unreleased section is correctly there
+
+UNRELEASED_COUNT="$(grep -c '^## Unreleased$' CHANGELOG.md || true)"
+if [[ "$UNRELEASED_COUNT" -eq 0 ]]; then
+  echo "error: CHANGELOG.md has no '## Unreleased' section to promote" >&2
+  exit 1
+elif [[ "$UNRELEASED_COUNT" -gt 1 ]]; then
+  echo "error: CHANGELOG.md has ${UNRELEASED_COUNT} '## Unreleased' sections; expected exactly one" >&2
+  exit 1
+fi
+
+# Bump version and check tag
+OLD_VERSION="$(uv version --short)"
+NEW_VERSION="$(uv version --bump "$BUMP" --dry-run --short)"
+TAG="v${NEW_VERSION}"
+RELEASE_DATE="$(date +%Y-%m-%d)"
+
+echo "==> Bumping $BUMP version..."
+echo "    Current version: $OLD_VERSION"
+echo "    New version:     $NEW_VERSION"
+echo "    Tag:             $TAG"
+echo "    Date:            $RELEASE_DATE"
+
+if git rev-parse -q --verify "refs/tags/$TAG" >/dev/null 2>&1; then
+  echo "error: tag '$TAG' already exists" >&2
+  echo "error: refusing to bump $BUMP version" >&2
+  exit 1
+fi
+uv version --bump "$BUMP"
+
+# Promote CHANGELOG `Unreleased` to the new version
+echo "==> Promoting CHANGELOG Unreleased -> ${NEW_VERSION} (${RELEASE_DATE})"
+sed -i "s/^## Unreleased$/## ${NEW_VERSION} \xe2\x80\x94 ${RELEASE_DATE}/" CHANGELOG.md
+
+# Commit
+COMMIT_MSG="chore(release): ${NEW_VERSION}"
+echo "==> Committing: $COMMIT_MSG"
+
+if is_jj; then
+  jj commit -m "$COMMIT_MSG"
+else
+  git add pyproject.toml CHANGELOG.md
+  git commit -m "$COMMIT_MSG"
+fi
+
+# Build the tag annotation from the just-promoted CHANGELOG section.
+# Title is "release: $(uv version)"; body is the section content (the
+# lines between the new `## <ver> ...` heading and the next `## ` heading).
+TAG_TITLE="release: $(uv version)"
+TAG_BODY="$(awk -v ver="$NEW_VERSION" -v prev="$OLD_VERSION" '
+  $0 ~ "^## " ver "( |$)" { capture = 1; next }
+  capture && /^## / {
+    if ($0 !~ "^## " prev "( |$)") {
+      printf "error: expected next changelog heading to be %s, got: %s\n", \
+        "## " prev, $0 > "/dev/stderr"
+      exit 2
+    }
+    exit
+  }
+  capture { print }
+' CHANGELOG.md)"
+
+# Tag
+echo "==> Tagging $TAG"
+if is_jj; then
+  jj git import 2>/dev/null || true
+fi
+printf '%s\n\n%s\n' "$TAG_TITLE" "$TAG_BODY" \
+  | git tag -a "$TAG" --cleanup=verbatim -F -
+if is_jj; then
+  jj git import 2>/dev/null || true
+fi
+
+echo ""
+echo "Done! Created tag: ${TAG}"
+echo "To publish, push the tag:  git push origin ${TAG}"

{morphata-2.0.0 → morphata-2.0.2}/docs/api/modules.rst

@@ -13,6 +13,8 @@
    morphata.acceptance
    morphata.hoa
    morphata.logic.ltl
+   morphata.logic.sere
+   morphata.logic.psl
    morphata.logic.strel
    morphata.operators
    morphata.operators.matrix

morphata-2.0.2/docs/api/morphata.logic.psl.rst

@@ -0,0 +1,15 @@
+PSL
+===
+
+Property Specification Language to Alternating Automaton conversion.
+
+Finite-trace (PSLf) and omega-trace (Büchi) acceptance are both
+supported via the ``finite`` keyword argument to
+:func:`~morphata.logic.psl.psl_to_automaton`. Suffix implications
+follow Spot's overlapping semantics: the last symbol matched by the
+SERE prefix is shared with the first position at which the
+continuation is evaluated.
+
+.. automodule:: morphata.logic.psl
+   :members:
+   :show-inheritance:

morphata-2.0.2/docs/api/morphata.logic.sere.rst

@@ -0,0 +1,9 @@
+SERE
+====
+
+Sequential Extended Regular Expression to Alternating Finite Automaton
+conversion.
+
+.. automodule:: morphata.logic.sere
+   :members:
+   :show-inheritance:

{morphata-2.0.0 → morphata-2.0.2}/docs/conf.py

@@ -27,7 +27,7 @@ extensions = [
 ]
 
 templates_path = ["_templates"]
-exclude_patterns = ["_build", "Thumbs.db", ".DS_Store"]
+exclude_patterns = ["_build", "Thumbs.db", ".DS_Store", "superpowers"]
 
 autodoc_default_options = {
     "members": True,