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 - the base level
        self._store = {}
        # Stack of transactions - each transaction is a dict of changes
        self._transactions = []
    
    def get(self, key):
        # Look through transactions from innermost to outermost
        for i in range(len(self._transactions) - 1, -1, -1):
            transaction = self._transactions[i]
            if key in transaction:
                # If key is explicitly deleted in this transaction, return None
                if transaction[key] is None:
                    return None
                return transaction[key]
        
        # If not found in any transaction, check the committed store
        return self._store.get(key)
    
    def set(self, key, value):
        # If we have open transactions, modify the innermost one
        if self._transactions:
            # Get the innermost transaction
            innermost = self._transactions[-1]
            # Set the key in the transaction (None means delete)
            innermost[key] = value
        else:
            # Otherwise, modify the committed store directly
            self._store[key] = value
    
    def delete(self, key):
        # If we have open transactions, mark deletion in the innermost one
        if self._transactions:
            # Get the innermost transaction
            innermost = self._transactions[-1]
            # Mark as deleted (None value)
            innermost[key] = None
        else:
            # Otherwise, delete from the committed store directly
            self._store.pop(key, None)
    
    def keys(self):
        # Collect all visible keys
        visible_keys = set()
        
        # Process transactions from outer to inner to respect the order
        for transaction in self._transactions:
            for key, value in transaction.items():
                if value is None:
                    # Key was deleted
                    visible_keys.discard(key)
                else:
                    # Key was set or updated
                    visible_keys.add(key)
        
        # Add keys from committed store that haven't been deleted
        for key in self._store:
            if key not in visible_keys:
                # Check if this key was deleted in any transaction
                deleted = False
                for i in range(len(self._transactions) - 1, -1, -1):
                    transaction = self._transactions[i]
                    if key in transaction and transaction[key] is None:
                        deleted = True
                        break
                if not deleted:
                    visible_keys.add(key)
        
        return sorted(list(visible_keys))
    
    def __len__(self):
        return len(self.keys())
    
    def begin(self):
        # Open a new transaction - add an empty dict to the stack
        self._transactions.append({})
    
    def commit(self):
        # Merge innermost transaction into its parent or committed store
        if not self._transactions:
            raise RuntimeError("No open transaction")
        
        # Get the innermost transaction
        innermost = self._transactions.pop()
        
        # If there's a parent transaction, merge changes into it
        if self._transactions:
            parent = self._transactions[-1]
            for key, value in innermost.items():
                parent[key] = value
        else:
            # Otherwise, merge into the committed store
            for key, value in innermost.items():
                if value is None:
                    self._store.pop(key, None)
                else:
                    self._store[key] = value
    
    def rollback(self):
        # Discard the innermost transaction
        if not self._transactions:
            raise RuntimeError("No open transaction")
        
        # Simply remove the innermost transaction from the stack
        self._transactions.pop()
```