py-12-txn-kvstore

# Transactional key-value store

Implement a file **`solution.py`** containing a class `KVStore` that behaves like an in-memory
key-value map with **nested transactions**.

```python
class KVStore:
    def __init__(self): ...
    def get(self, key):          ...   # current value, or None if absent
    def set(self, key, value):   ...
    def delete(self, key):       ...   # remove key (no-op if absent)
    def keys(self):              ...   # sorted list of currently-visible keys
    def __len__(self):           ...   # number of currently-visible keys

    def begin(self):    ...            # open a new (nested) transaction
    def commit(self):   ...            # merge the innermost open transaction into its parent
    def rollback(self): ...            # discard the innermost open transaction
```

## Semantics

- With **no open transaction**, `set`/`delete` mutate the committed store directly.
- `begin()` opens a transaction. Transactions **nest**: a second `begin()` opens a child of the
  first. All `set`/`delete` calls apply to the **innermost** open transaction only.
- `get`, `keys`, and `__len__` always reflect the **currently-visible** state: the committed store
  overlaid by every open transaction in order (innermost wins). A key `delete`d in an open
  transaction is invisible even if it exists in the committed store.
- `commit()` merges the innermost transaction's changes (both sets and deletes) into its parent
  (the enclosing transaction, or the committed store if it was the outermost). The transaction is
  then closed.
- `rollback()` discards the innermost transaction's changes entirely and closes it.
- `commit()` or `rollback()` with **no open transaction** must raise `RuntimeError`.
- `keys()` returns the visible keys in **sorted order**.

## Example

```python
s = KVStore()
s.set("a", 1)
s.begin()
s.set("a", 2)
s.set("b", 3)
assert s.get("a") == 2          # innermost transaction wins
s.begin()
s.delete("a")
assert s.get("a") is None       # deleted in the inner transaction
assert s.get("b") == 3          # still visible from the outer transaction
s.rollback()                    # discard the inner transaction
assert s.get("a") == 2          # back to the outer transaction's value
s.commit()                      # merge outer transaction into the committed store
assert s.get("a") == 2 and s.get("b") == 3
assert s.keys() == ["a", "b"]
```

import pytest

from solution import KVStore


def test_basic_set_get_delete():
    s = KVStore()
    assert s.get("a") is None
    s.set("a", 1)
    s.set("b", 2)
    assert s.get("a") == 1
    assert s.get("b") == 2
    s.delete("a")
    assert s.get("a") is None
    s.delete("missing")  # no-op, must not raise


def test_len_and_keys_sorted():
    s = KVStore()
    s.set("z", 1)
    s.set("a", 1)
    s.set("m", 1)
    assert s.keys() == ["a", "m", "z"]
    assert len(s) == 3
    s.delete("m")
    assert s.keys() == ["a", "z"]
    assert len(s) == 2


def test_transaction_isolation_then_commit():
    s = KVStore()
    s.set("a", 1)
    s.begin()
    s.set("a", 2)
    s.set("b", 3)
    assert s.get("a") == 2
    assert s.get("b") == 3
    s.commit()
    assert s.get("a") == 2
    assert s.get("b") == 3


def test_rollback_discards_changes():
    s = KVStore()
    s.set("a", 1)
    s.begin()
    s.set("a", 99)
    s.set("b", 5)
    s.rollback()
    assert s.get("a") == 1
    assert s.get("b") is None
    assert s.keys() == ["a"]


def test_delete_within_transaction_is_isolated():
    s = KVStore()
    s.set("a", 1)
    s.begin()
    s.delete("a")
    assert s.get("a") is None
    assert s.keys() == []
    assert len(s) == 0
    s.rollback()
    assert s.get("a") == 1  # delete was rolled back


def test_commit_propagates_delete_to_committed_store():
    s = KVStore()
    s.set("a", 1)
    s.begin()
    s.delete("a")
    s.commit()
    assert s.get("a") is None
    assert s.keys() == []


def test_nested_transactions_inner_rollback():
    s = KVStore()
    s.set("a", 1)
    s.begin()
    s.set("a", 2)
    s.set("b", 3)
    s.begin()
    s.delete("a")
    assert s.get("a") is None
    assert s.get("b") == 3
    s.rollback()             # discard inner
    assert s.get("a") == 2   # outer value restored
    s.commit()               # merge outer into committed
    assert s.get("a") == 2
    assert s.get("b") == 3


def test_nested_commit_merges_into_parent_not_base():
    s = KVStore()
    s.begin()
    s.set("a", 1)
    s.begin()
    s.set("a", 2)
    s.set("b", 3)
    s.commit()               # inner -> outer (NOT committed store yet)
    assert s.get("a") == 2
    assert s.get("b") == 3
    s.rollback()             # discard outer -> everything gone
    assert s.get("a") is None
    assert s.get("b") is None
    assert len(s) == 0


def test_commit_without_transaction_raises():
    s = KVStore()
    with pytest.raises(RuntimeError):
        s.commit()


def test_rollback_without_transaction_raises():
    s = KVStore()
    with pytest.raises(RuntimeError):
        s.rollback()


def test_deep_nesting_visibility_and_merge():
    s = KVStore()
    s.set("k", 0)
    for depth in range(1, 6):
        s.begin()
        s.set("k", depth)
        assert s.get("k") == depth
    # commit all five layers down to the base
    for _ in range(5):
        s.commit()
    assert s.get("k") == 5
    assert s.keys() == ["k"]


def test_reset_value_after_delete_in_same_transaction():
    s = KVStore()
    s.set("a", 1)
    s.begin()
    s.delete("a")
    s.set("a", 7)            # re-add after delete within the same transaction
    assert s.get("a") == 7
    s.commit()
    assert s.get("a") == 7

You are an expert programmer. Solve the task exactly as specified. Output your solution as fenced code blocks using the required file name(s) and the exact function/type signatures requested. Prefer correctness; do not include prose outside code unless asked.

```python
class KVStore:
    def __init__(self):
        # The committed store (base layer)
        self._store = {}
        # Stack of transactions: each transaction is a dict of changes
        # Each entry maps key -> value (or None for delete operations)
        self._transactions = []

    def get(self, key):
        # Check from innermost to outermost transaction first
        for txn in reversed(self._transactions):
            if key in txn:
                val = txn[key]
                return val  # None means deleted, otherwise return the value
        
        # If not found in any transaction, check the committed store
        return self._store.get(key)

    def set(self, key, value):
        # If there's an open transaction, apply to the innermost one
        if self._transactions:
            self._transactions[-1][key] = value
        else:
            # Otherwise, apply directly to the committed store
            self._store[key] = value

    def delete(self, key):
        # If there's an open transaction, mark as deleted (None) in the innermost one
        if self._transactions:
            self._transactions[-1][key] = None
        else:
            # Otherwise, delete from the committed store if present
            if key in self._store:
                del self._store[key]

    def keys(self):
        # Collect all keys visible in the current state
        result = set()
        
        # First add keys from the committed store
        result.update(self._store.keys())
        
        # Then overlay with transaction changes (innermost first)
        for txn in reversed(self._transactions):
            for key, value in txn.items():
                if value is None:
                    # Delete operation: remove key if present
                    result.discard(key)
                else:
                    # Set operation: add or update key
                    result.add(key)
        
        return sorted(result)

    def __len__(self):
        return len(self.keys())

    def begin(self):
        # Start a new transaction (empty dict to hold changes)
        self._transactions.append({})

    def commit(self):
        if not self._transactions:
            raise RuntimeError("No open transaction to commit")
        
        # Get the innermost transaction
        innermost_txn = self._transactions.pop()
        
        # If there's still a parent transaction, merge into it
        if self._transactions:
            parent_txn = self._transactions[-1]
            for key, value in innermost_txn.items():
                parent_txn[key] = value
        else:
            # No parent transaction: merge into the committed store
            for key, value in innermost_txn.items():
                if value is None:
                    # Delete operation: remove from committed store
                    self._store.pop(key, None)
                else:
                    # Set operation: update committed store
                    self._store[key] = value

    def rollback(self):
        if not self._transactions:
            raise RuntimeError("No open transaction to rollback")
        
        # Simply discard the innermost transaction
        self._transactions.pop()
```