Fix critical bugs and add missing exception handling

- Fix delete_key: directly call DeleteKey instead of opening key first
- Fix delete_sub_keys: enumerate at index 0 (keys shift after deletion)
- Add exception handling to set_reg_sz_value and create_key (now return bool)
- Fix TTL calculation in memory store (recalculate_ttl before use)
- Use else blocks in try-except for TRY300 linting compliance
- Update sync package to match async changes

Co-authored-by: William Easton <[email protected]>

Author: github-actions[bot]

key-value/key-value-aio/src/key_value/aio/stores/memory/store.py

@@ -153,6 +153,8 @@ def put(self, key: str, value: ManagedEntry) -> None:
             key: The key to store under.
             value: The ManagedEntry to store.
         """
+        # Recalculate TTL to get remaining time until expiration
+        value.recalculate_ttl()
         self._cache[key] = MemoryCacheEntry.from_managed_entry(managed_entry=value, ttl=value.ttl)
 
     def delete(self, key: str) -> bool:

key-value/key-value-aio/src/key_value/aio/stores/windows_registry/utils.py

@@ -23,17 +23,24 @@ def get_reg_sz_value(hive: HiveType, sub_key: str, value_name: str) -> str | Non
         return None
 
 
-def set_reg_sz_value(hive: HiveType, sub_key: str, value_name: str, value: str) -> None:
+def set_reg_sz_value(hive: HiveType, sub_key: str, value_name: str, value: str) -> bool:
     """Set a string value in the Windows Registry.
 
     Args:
         hive: The registry hive (e.g., winreg.HKEY_CURRENT_USER).
         sub_key: The registry subkey path.
         value_name: The name of the registry value to set.
         value: The string value to write.
+
+    Returns:
+        True if the value was set, False if the key doesn't exist or couldn't be accessed.
     """
-    with winreg.OpenKey(key=hive, sub_key=sub_key, access=winreg.KEY_WRITE) as reg_key:
-        winreg.SetValueEx(reg_key, value_name, 0, winreg.REG_SZ, value)
+    try:
+        with winreg.OpenKey(key=hive, sub_key=sub_key, access=winreg.KEY_WRITE) as reg_key:
+            winreg.SetValueEx(reg_key, value_name, 0, winreg.REG_SZ, value)
+            return True
+    except (FileNotFoundError, OSError):
+        return False
 
 
 def delete_reg_sz_value(hive: HiveType, sub_key: str, value_name: str) -> bool:
@@ -72,14 +79,22 @@ def has_key(hive: HiveType, sub_key: str) -> bool:
         return False
 
 
-def create_key(hive: HiveType, sub_key: str) -> None:
+def create_key(hive: HiveType, sub_key: str) -> bool:
     """Create a new registry key.
 
     Args:
         hive: The registry hive (e.g., winreg.HKEY_CURRENT_USER).
         sub_key: The registry subkey path to create.
+
+    Returns:
+        True if the key was created or already exists, False on error.
     """
-    winreg.CreateKey(hive, sub_key)
+    try:
+        winreg.CreateKey(hive, sub_key)
+    except OSError:
+        return False
+    else:
+        return True
 
 
 def delete_key(hive: HiveType, sub_key: str) -> bool:
@@ -93,32 +108,34 @@ def delete_key(hive: HiveType, sub_key: str) -> bool:
         True if the key was deleted, False if it didn't exist or couldn't be deleted.
     """
     try:
-        with winreg.OpenKey(key=hive, sub_key=sub_key, access=winreg.KEY_WRITE) as reg_key:
-            winreg.DeleteKey(reg_key, sub_key)
-            return True
+        winreg.DeleteKey(hive, sub_key)
     except (FileNotFoundError, OSError):
         return False
+    else:
+        return True
 
 
 def delete_sub_keys(hive: HiveType, sub_key: str) -> None:
-    """Delete all subkeys of a registry key.
+    """Delete all immediate subkeys of a registry key.
 
-    This function recursively deletes all subkeys under the specified registry key.
+    This function deletes all immediate child keys (non-recursive).
 
     Args:
         hive: The registry hive (e.g., winreg.HKEY_CURRENT_USER).
         sub_key: The registry subkey path whose subkeys should be deleted.
     """
     try:
         with winreg.OpenKey(key=hive, sub_key=sub_key, access=winreg.KEY_WRITE | winreg.KEY_ENUMERATE_SUB_KEYS) as reg_key:
-            index = 0
             while True:
-                if not (next_child_key := winreg.EnumKey(reg_key, index)):
+                try:
+                    # Always enumerate at index 0 since keys shift after deletion
+                    next_child_key = winreg.EnumKey(reg_key, 0)
+                except OSError:
+                    # No more subkeys
                     break
 
-                with contextlib.suppress(Exception):
+                # Key already deleted or can't be deleted, skip it
+                with contextlib.suppress(FileNotFoundError, OSError):
                     winreg.DeleteKey(reg_key, next_child_key)
-
-                index += 1
     except (FileNotFoundError, OSError):
         return

key-value/key-value-sync/src/key_value/sync/code_gen/stores/memory/store.py

@@ -27,7 +27,11 @@
 
 @dataclass
 class MemoryCacheEntry:
-    """A cache entry for the memory store."""
+    """A cache entry for the memory store.
+
+    This dataclass represents an entry in the MemoryStore cache, storing the JSON-serialized
+    value along with expiration metadata and the original TTL value at insertion time.
+    """
 
     json_str: str
 
@@ -37,14 +41,40 @@ class MemoryCacheEntry:
 
     @classmethod
     def from_managed_entry(cls, managed_entry: ManagedEntry, ttl: SupportsFloat | None = None) -> Self:
+        """Create a cache entry from a ManagedEntry.
+
+        Args:
+            managed_entry: The ManagedEntry to convert.
+            ttl: The TTL value at insertion time.
+
+        Returns:
+            A new MemoryCacheEntry.
+        """
         return cls(json_str=managed_entry.to_json(), expires_at=managed_entry.expires_at, ttl_at_insert=ttl)
 
     def to_managed_entry(self) -> ManagedEntry:
+        """Convert this cache entry to a ManagedEntry.
+
+        Returns:
+            A ManagedEntry reconstructed from the stored JSON.
+        """
         return ManagedEntry.from_json(json_str=self.json_str)
 
 
 def _memory_cache_ttu(_key: Any, value: MemoryCacheEntry, now: float) -> float:
-    """Calculate time-to-use for cache entries based on their TTL."""
+    """Calculate time-to-use for cache entries based on their TTL.
+
+    This function is used by TLRUCache to determine when entries should expire.
+    It calculates the expiration timestamp and updates the entry's expires_at field.
+
+    Args:
+        _key: The cache key (unused).
+        value: The cache entry.
+        now: The current time as an epoch timestamp.
+
+    Returns:
+        The expiration time as an epoch timestamp, or sys.maxsize if the entry has no TTL.
+    """
     if value.ttl_at_insert is None:
         return float(sys.maxsize)
 
@@ -56,7 +86,17 @@ def _memory_cache_ttu(_key: Any, value: MemoryCacheEntry, now: float) -> float:
 
 
 def _memory_cache_getsizeof(value: MemoryCacheEntry) -> int:
-    "Return size of cache entry (always 1 for entry counting)."
+    """Return size of cache entry (always 1 for entry counting).
+
+    This function is used by TLRUCache to determine entry sizes. Since we want to count
+    entries rather than measure memory usage, this always returns 1.
+
+    Args:
+        value: The cache entry (unused).
+
+    Returns:
+        Always returns 1 to enable entry-based size limiting.
+    """
     return 1
 
 
@@ -67,6 +107,12 @@ def _memory_cache_getsizeof(value: MemoryCacheEntry) -> int:
 
 
 class MemoryCollection:
+    """A fixed-size in-memory collection using TLRUCache.
+
+    This class wraps a time-aware LRU cache to provide TTL-based expiration
+    and automatic eviction of old entries when the cache reaches its size limit.
+    """
+
     _cache: TLRUCache[str, MemoryCacheEntry]
 
     def __init__(self, max_entries: int = DEFAULT_MAX_ENTRIES_PER_COLLECTION):
@@ -78,6 +124,14 @@ def __init__(self, max_entries: int = DEFAULT_MAX_ENTRIES_PER_COLLECTION):
         self._cache = TLRUCache[str, MemoryCacheEntry](maxsize=max_entries, ttu=_memory_cache_ttu, getsizeof=_memory_cache_getsizeof)
 
     def get(self, key: str) -> ManagedEntry | None:
+        """Retrieve an entry from the collection.
+
+        Args:
+            key: The key to retrieve.
+
+        Returns:
+            The ManagedEntry if found and not expired, None otherwise.
+        """
         managed_entry_str: MemoryCacheEntry | None = self._cache.get(key)
 
         if managed_entry_str is None:
@@ -88,9 +142,25 @@ def get(self, key: str) -> ManagedEntry | None:
         return managed_entry
 
     def put(self, key: str, value: ManagedEntry) -> None:
+        """Store an entry in the collection.
+
+        Args:
+            key: The key to store under.
+            value: The ManagedEntry to store.
+        """
+        # Recalculate TTL to get remaining time until expiration
+        value.recalculate_ttl()
         self._cache[key] = MemoryCacheEntry.from_managed_entry(managed_entry=value, ttl=value.ttl)
 
     def delete(self, key: str) -> bool:
+        """Delete an entry from the collection.
+
+        Args:
+            key: The key to delete.
+
+        Returns:
+            True if the key was deleted, False if it didn't exist.
+        """
         return self._cache.pop(key, None) is not None
 
     def keys(self, *, limit: int | None = None) -> list[str]:

key-value/key-value-sync/src/key_value/sync/code_gen/stores/windows_registry/utils.py

@@ -26,17 +26,24 @@ def get_reg_sz_value(hive: HiveType, sub_key: str, value_name: str) -> str | Non
         return None
 
 
-def set_reg_sz_value(hive: HiveType, sub_key: str, value_name: str, value: str) -> None:
+def set_reg_sz_value(hive: HiveType, sub_key: str, value_name: str, value: str) -> bool:
     """Set a string value in the Windows Registry.
 
     Args:
         hive: The registry hive (e.g., winreg.HKEY_CURRENT_USER).
         sub_key: The registry subkey path.
         value_name: The name of the registry value to set.
         value: The string value to write.
+
+    Returns:
+        True if the value was set, False if the key doesn't exist or couldn't be accessed.
     """
-    with winreg.OpenKey(key=hive, sub_key=sub_key, access=winreg.KEY_WRITE) as reg_key:
-        winreg.SetValueEx(reg_key, value_name, 0, winreg.REG_SZ, value)
+    try:
+        with winreg.OpenKey(key=hive, sub_key=sub_key, access=winreg.KEY_WRITE) as reg_key:
+            winreg.SetValueEx(reg_key, value_name, 0, winreg.REG_SZ, value)
+            return True
+    except (FileNotFoundError, OSError):
+        return False
 
 
 def delete_reg_sz_value(hive: HiveType, sub_key: str, value_name: str) -> bool:
@@ -75,14 +82,22 @@ def has_key(hive: HiveType, sub_key: str) -> bool:
         return False
 
 
-def create_key(hive: HiveType, sub_key: str) -> None:
+def create_key(hive: HiveType, sub_key: str) -> bool:
     """Create a new registry key.
 
     Args:
         hive: The registry hive (e.g., winreg.HKEY_CURRENT_USER).
         sub_key: The registry subkey path to create.
+
+    Returns:
+        True if the key was created or already exists, False on error.
     """
-    winreg.CreateKey(hive, sub_key)
+    try:
+        winreg.CreateKey(hive, sub_key)
+    except OSError:
+        return False
+    else:
+        return True
 
 
 def delete_key(hive: HiveType, sub_key: str) -> bool:
@@ -96,32 +111,34 @@ def delete_key(hive: HiveType, sub_key: str) -> bool:
         True if the key was deleted, False if it didn't exist or couldn't be deleted.
     """
     try:
-        with winreg.OpenKey(key=hive, sub_key=sub_key, access=winreg.KEY_WRITE) as reg_key:
-            winreg.DeleteKey(reg_key, sub_key)
-            return True
+        winreg.DeleteKey(hive, sub_key)
     except (FileNotFoundError, OSError):
         return False
+    else:
+        return True
 
 
 def delete_sub_keys(hive: HiveType, sub_key: str) -> None:
-    """Delete all subkeys of a registry key.
+    """Delete all immediate subkeys of a registry key.
 
-    This function recursively deletes all subkeys under the specified registry key.
+    This function deletes all immediate child keys (non-recursive).
 
     Args:
         hive: The registry hive (e.g., winreg.HKEY_CURRENT_USER).
         sub_key: The registry subkey path whose subkeys should be deleted.
     """
     try:
         with winreg.OpenKey(key=hive, sub_key=sub_key, access=winreg.KEY_WRITE | winreg.KEY_ENUMERATE_SUB_KEYS) as reg_key:
-            index = 0
             while True:
-                if not (next_child_key := winreg.EnumKey(reg_key, index)):
+                try:
+                    # Always enumerate at index 0 since keys shift after deletion
+                    next_child_key = winreg.EnumKey(reg_key, 0)
+                except OSError:
+                    # No more subkeys
                     break
 
-                with contextlib.suppress(Exception):
+                # Key already deleted or can't be deleted, skip it
+                with contextlib.suppress(FileNotFoundError, OSError):
                     winreg.DeleteKey(reg_key, next_child_key)
-
-                index += 1
     except (FileNotFoundError, OSError):
         return