chore: cleanup comments

Author: tbhb

src/jsonlt/_state.py

@@ -48,7 +48,6 @@ def compute_logical_state(
     state: dict[Key, JSONObject] = {}
 
     for obj in operations:
-        # Extract the key from the operation
         key = extract_key(obj, key_specifier)
 
         # Determine operation type and apply

src/jsonlt/_table.py

@@ -160,21 +160,16 @@ def _load(self, caller_key: "KeySpecifier | None" = None) -> None:
             InvalidKeyError: If the key specifier is invalid or mismatches
                 the header, or if the file has operations but no key specifier.
         """
-        # Check if file exists - if not, treat as empty table
         if not self._path.exists():
             self._load_empty_table(caller_key)
             return
 
-        # Read and parse the file
         header, operations = read_table_file(
             self._path, max_file_size=self._max_file_size
         )
         self._header = header
-
-        # Track file stats for auto-reload
         self._update_file_stats()
 
-        # Resolve which key specifier to use
         resolved_key = self._resolve_key_specifier(caller_key, header, operations)
         if resolved_key is None:
             # Empty file with no key specifier - OK for now
@@ -185,7 +180,6 @@ def _load(self, caller_key: "KeySpecifier | None" = None) -> None:
 
         self._key_specifier = resolved_key
 
-        # Compute logical state if we have operations
         if operations:
             self._state = compute_logical_state(operations, self._key_specifier)
         else:
@@ -205,12 +199,10 @@ def _load_from_content(self, content: bytes) -> None:
             ParseError: If the content contains invalid data.
         """
         if not content:
-            # Empty content - nothing to load
             self._state = {}
             self._cached_sorted_keys = None
             return
 
-        # Parse the content
         header, operations = parse_table_content(content)
         self._header = header
 
@@ -223,7 +215,6 @@ def _load_from_content(self, content: bytes) -> None:
 
         self._key_specifier = resolved_key
 
-        # Compute logical state if we have operations
         if operations:
             self._state = compute_logical_state(operations, self._key_specifier)
         else:
@@ -395,8 +386,6 @@ def reload(self) -> None:
         self._load()
         self._cached_sorted_keys = None
 
-    # --- Write Operations ---
-
     def _require_key_specifier(self) -> KeySpecifier:
         """Return key specifier or raise InvalidKeyError if not set."""
         if self._key_specifier is None:
@@ -525,14 +514,11 @@ def delete(self, key: Key) -> bool:
         # Validate key arity matches specifier
         validate_key_arity(key, key_specifier)
 
-        # Validate key length
         validate_key_length(key)
 
-        # Build tombstone
         tombstone = build_tombstone(key, key_specifier)
         serialized = serialize_json(tombstone)
 
-        # Write under lock - returns whether key existed (checked after reload)
         return self._write_with_lock(serialized, key, None)
 
     def clear(self) -> None:

src/jsonlt/_transaction.py

@@ -149,13 +149,9 @@ def put(self, record: "JSONObject") -> None:
         """
         self._require_active()
 
-        # Check for unpaired surrogates in all strings
         validate_no_surrogates(record)
-
-        # Validate record structure (missing fields, invalid key types, $ fields)
         validate_record(record, self._key_specifier)
 
-        # Extract and validate key
         key = extract_key(record, self._key_specifier)
         validate_key_length(key)
 
@@ -169,12 +165,10 @@ def put(self, record: "JSONObject") -> None:
         # Cache serialized form before deep copy (record hasn't been modified)
         self._buffer_serialized[key] = serialized
 
-        # Buffer the update (only keep latest value per key)
         record_copy = copy.deepcopy(record)
         self._buffer_updates[key] = record_copy
         self._written_keys.add(key)
 
-        # Update snapshot
         self._snapshot[key] = record_copy
         self._cached_sorted_keys = None
 
@@ -196,21 +190,15 @@ def delete(self, key: Key) -> bool:
         """
         self._require_active()
 
-        # Validate key arity matches specifier
         validate_key_arity(key, self._key_specifier)
-
-        # Validate key length
         validate_key_length(key)
 
-        # Check if key exists in snapshot
         existed = key in self._snapshot
 
-        # Buffer the delete (only keep latest state per key)
         self._buffer_updates[key] = None
         _ = self._buffer_serialized.pop(key, None)
         self._written_keys.add(key)
 
-        # Update snapshot
         if existed:
             del self._snapshot[key]
         self._cached_sorted_keys = None

tests/benchmarks/test_bench_memory.py

@@ -1,9 +1,3 @@
-"""Memory profiling benchmarks for JSONLT.
-
-This module contains memory usage benchmarks using pytest-memray to ensure
-memory consumption stays within expected bounds.
-"""
-
 import sys
 from typing import TYPE_CHECKING
 
@@ -26,8 +20,6 @@
 
 
 class TestMemoryLoad:
-    """Memory benchmarks for loading tables."""
-
     @pytest.mark.limit_memory("10 MB")
     def test_load_1k_small_records(self, tmp_path: "Path") -> None:
         records = generate_records("string", "small", 1000)
@@ -88,8 +80,6 @@ def test_load_1k_large_records(self, tmp_path: "Path") -> None:
 
 
 class TestMemoryLoadKeyTypes:
-    """Memory benchmarks for loading with different key types."""
-
     @pytest.mark.limit_memory("10 MB")
     def test_load_1k_integer_keys(self, tmp_path: "Path") -> None:
         records = generate_records("integer", "small", 1000)
@@ -130,8 +120,6 @@ def test_load_10k_tuple_keys(self, tmp_path: "Path") -> None:
 
 
 class TestMemoryRead:
-    """Memory benchmarks for read operations."""
-
     @pytest.mark.limit_memory("15 MB")
     def test_all_1k_records(self, tmp_path: "Path") -> None:
         records = generate_records("string", "small", 1000)
@@ -175,8 +163,6 @@ def test_keys_1k_records(self, tmp_path: "Path") -> None:
 
 
 class TestMemoryWrite:
-    """Memory benchmarks for write operations."""
-
     @pytest.mark.limit_memory("15 MB")
     def test_put_to_1k_table(self, tmp_path: "Path") -> None:
         records = generate_records("string", "small", 1000)