TSVZ 4.6__tar.gz → 4.8__tar.gz

{tsvz-4.6 → tsvz-4.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: TSVZ
-Version: 4.6
+Version: 4.8
 Summary: Key-value store kept in a TSV / CSV / NSV / PSV file, with tsvz-spec-v1 support
 Home-page: https://github.com/yufei-pan/TSVZ
 Author: Yufei Pan
@@ -34,7 +34,7 @@ key-value store in a delimiter-separated text file**. The first column of each
 row is the key; the file behaves like an ordered dictionary that is persisted to
 disk as you change it.
 
-**Version 4.6**, Python **3.6+**, one self-contained module (`TSVZ.py`): drop it
+**Version 4.8**, Python **3.6+**, one self-contained module (`TSVZ.py`): drop it
 next to your code and `import TSVZ`, or install it.
 
 ```bash
@@ -224,6 +224,7 @@ delimiter or encoding argument that conflicts with the extension.
 | L4 | New warnings on stderr (invalid encoding, lines dropped by `strict`); data unchanged. |
 | L5 | A damaged compressed file is read up to the damage instead of raising. |
 | L6 | `mapToFile` no longer glues a row it adds at the end of the file to the next one. |
+| L7 | `TSVZed`'s `in` and `get` find a key as `t[key]` does: the live key equal to it, else the key right-stripped. 3.39 matched them exactly, so `'x ' in t` was false while `t['x ']` read `x`, and `t.setdefault('x ', …)` overwrote `x`. |
 
 ### `.tsvz`, `.csvz`, `.nsvz`, `.psvz`: now tsvz-spec-v1
 
@@ -243,6 +244,7 @@ delimiter or encoding argument that conflicts with the extension.
 | S12 | `TSVZedLite.clear()` and `clear_file()` raise `OSError` when the clear is refused (a part could not be read, the path names one part of a store, or the store kept changing). Memory is reloaded from the unchanged store first. |
 | S13 | Compressed parts are written in members of at most 1 MiB of records (`#_member_size_#`), Zstandard frames with a checksum; an append never reads or repairs the part. |
 | S14 | A zero byte in a value is written `<NUL>`, and a raw zero byte in a record is read as zero-fill damage (spec §4.9): under the default `recover` only the bytes after it are read. **A value that 4.2 or 4.3 wrote with a raw zero byte therefore reads differently in 4.4.** Such values are rare; before upgrading, `grep -c -P '\x00' store.tsvz` (any `.tsvz`, `.csvz` or `.psvz` part) finds them. Stop 4.2 and 4.3 handlers before upgrading: they read `<NUL>` as text, as they read `<CR>`. |
+| S15 | A lookup (`t[key]`, `in`, `get`, `del`, `pop`, `setdefault`) takes the live key equal to the one given before the right-stripped one, so a key ending in whitespace (written while `#_strip_trailing_whites_#` was false) can be read and deleted by name (spec §20.2.7). Setting a key still right-strips it. |
 
 ### The `tsvz` command
 
@@ -256,12 +258,13 @@ and `-d=,`, except the ones C5 and C9 list.
 | C3 | `read` and `scrub` of a missing store exit 1 with a message (3.39: exit 0, and `read` printed "File not found" on stdout). |
 | C4 | `delete` deletes every KEY it is given (3.39: only the first). |
 | C5 | `append` or `delete` without a KEY, or with an empty KEY, is a usage error with exit 2 (3.39 wrote an empty line). |
-| C6 | A `clear` or `scrub` that writes nothing (one part of a multi-part store, a store that kept changing) exits 1. |
+| C6 | A `clear` or `scrub` that writes nothing (one part of a multi-part store, a store that kept changing, a part that declares a spec version newer than 1, per spec §19.4 and §19.8) exits 1. |
 | C7 | `-c/--header`, `--defaults`, `-s/--strict` and `-f/--force` are undocumented aliases of the `--x-` options. `--x-header` and `--x-defaults` keep non-ASCII text. |
 | C8 | Usage errors print tsvz's own message, exit 2; the `-h` text is new. |
 | C9 | Arguments after STORE for `read`, `clear` and `scrub` are a usage error, exit 2 (3.39 ignored them, so `clear junk` cleared the file). |
 | C10 | The table (a terminal, or `--format table`) of `get`, `keys`, `pop`, `popitem`, `setdefault`, and of `read` on a `.tsvz`-family store, shows the rows only: no row is drawn as a header, and no row is cut to the first row's or the terminal's width. `read` of a `.tsv`-family file keeps 3.39's table, whose first row is the file's header line. |
 | C11 | The table shows control characters, bidi controls and line separators as escapes (`\r`, `\n`, `\t`, `\xNN`, `\uNNNN`), so no value can move the cursor, reorder the line or restyle the terminal. It sizes columns in terminal columns, so CJK text (two columns a character) lines up. The table is for reading: a backslash in a value is shown as is, so use records for exact values. |
+| C12 | While stripping is on, `get`, `has`, `pop`, `delete` and `setdefault` take the live key equal to a KEY ending in a space or tab before the stripped one (spec §20.2.7), so `tsvz keys s \| tsvz delete s -` deletes every key. `delete` of such a KEY reads the store first, and exits 1 without writing when the store cannot be read whole. |
 
 ## Spec deviations and interpretations
 

{tsvz-4.6 → tsvz-4.8}/README.md

@@ -7,7 +7,7 @@ key-value store in a delimiter-separated text file**. The first column of each
 row is the key; the file behaves like an ordered dictionary that is persisted to
 disk as you change it.
 
-**Version 4.6**, Python **3.6+**, one self-contained module (`TSVZ.py`): drop it
+**Version 4.8**, Python **3.6+**, one self-contained module (`TSVZ.py`): drop it
 next to your code and `import TSVZ`, or install it.
 
 ```bash
@@ -197,6 +197,7 @@ delimiter or encoding argument that conflicts with the extension.
 | L4 | New warnings on stderr (invalid encoding, lines dropped by `strict`); data unchanged. |
 | L5 | A damaged compressed file is read up to the damage instead of raising. |
 | L6 | `mapToFile` no longer glues a row it adds at the end of the file to the next one. |
+| L7 | `TSVZed`'s `in` and `get` find a key as `t[key]` does: the live key equal to it, else the key right-stripped. 3.39 matched them exactly, so `'x ' in t` was false while `t['x ']` read `x`, and `t.setdefault('x ', …)` overwrote `x`. |
 
 ### `.tsvz`, `.csvz`, `.nsvz`, `.psvz`: now tsvz-spec-v1
 
@@ -216,6 +217,7 @@ delimiter or encoding argument that conflicts with the extension.
 | S12 | `TSVZedLite.clear()` and `clear_file()` raise `OSError` when the clear is refused (a part could not be read, the path names one part of a store, or the store kept changing). Memory is reloaded from the unchanged store first. |
 | S13 | Compressed parts are written in members of at most 1 MiB of records (`#_member_size_#`), Zstandard frames with a checksum; an append never reads or repairs the part. |
 | S14 | A zero byte in a value is written `<NUL>`, and a raw zero byte in a record is read as zero-fill damage (spec §4.9): under the default `recover` only the bytes after it are read. **A value that 4.2 or 4.3 wrote with a raw zero byte therefore reads differently in 4.4.** Such values are rare; before upgrading, `grep -c -P '\x00' store.tsvz` (any `.tsvz`, `.csvz` or `.psvz` part) finds them. Stop 4.2 and 4.3 handlers before upgrading: they read `<NUL>` as text, as they read `<CR>`. |
+| S15 | A lookup (`t[key]`, `in`, `get`, `del`, `pop`, `setdefault`) takes the live key equal to the one given before the right-stripped one, so a key ending in whitespace (written while `#_strip_trailing_whites_#` was false) can be read and deleted by name (spec §20.2.7). Setting a key still right-strips it. |
 
 ### The `tsvz` command
 
@@ -229,12 +231,13 @@ and `-d=,`, except the ones C5 and C9 list.
 | C3 | `read` and `scrub` of a missing store exit 1 with a message (3.39: exit 0, and `read` printed "File not found" on stdout). |
 | C4 | `delete` deletes every KEY it is given (3.39: only the first). |
 | C5 | `append` or `delete` without a KEY, or with an empty KEY, is a usage error with exit 2 (3.39 wrote an empty line). |
-| C6 | A `clear` or `scrub` that writes nothing (one part of a multi-part store, a store that kept changing) exits 1. |
+| C6 | A `clear` or `scrub` that writes nothing (one part of a multi-part store, a store that kept changing, a part that declares a spec version newer than 1, per spec §19.4 and §19.8) exits 1. |
 | C7 | `-c/--header`, `--defaults`, `-s/--strict` and `-f/--force` are undocumented aliases of the `--x-` options. `--x-header` and `--x-defaults` keep non-ASCII text. |
 | C8 | Usage errors print tsvz's own message, exit 2; the `-h` text is new. |
 | C9 | Arguments after STORE for `read`, `clear` and `scrub` are a usage error, exit 2 (3.39 ignored them, so `clear junk` cleared the file). |
 | C10 | The table (a terminal, or `--format table`) of `get`, `keys`, `pop`, `popitem`, `setdefault`, and of `read` on a `.tsvz`-family store, shows the rows only: no row is drawn as a header, and no row is cut to the first row's or the terminal's width. `read` of a `.tsv`-family file keeps 3.39's table, whose first row is the file's header line. |
 | C11 | The table shows control characters, bidi controls and line separators as escapes (`\r`, `\n`, `\t`, `\xNN`, `\uNNNN`), so no value can move the cursor, reorder the line or restyle the terminal. It sizes columns in terminal columns, so CJK text (two columns a character) lines up. The table is for reading: a backslash in a value is shown as is, so use records for exact values. |
+| C12 | While stripping is on, `get`, `has`, `pop`, `delete` and `setdefault` take the live key equal to a KEY ending in a space or tab before the stripped one (spec §20.2.7), so `tsvz keys s \| tsvz delete s -` deletes every key. `delete` of such a KEY reads the store first, and exits 1 without writing when the store cannot be read whole. |
 
 ## Spec deviations and interpretations
 

{tsvz-4.6 → tsvz-4.8}/TSVZ.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: TSVZ
-Version: 4.6
+Version: 4.8
 Summary: Key-value store kept in a TSV / CSV / NSV / PSV file, with tsvz-spec-v1 support
 Home-page: https://github.com/yufei-pan/TSVZ
 Author: Yufei Pan
@@ -34,7 +34,7 @@ key-value store in a delimiter-separated text file**. The first column of each
 row is the key; the file behaves like an ordered dictionary that is persisted to
 disk as you change it.
 
-**Version 4.6**, Python **3.6+**, one self-contained module (`TSVZ.py`): drop it
+**Version 4.8**, Python **3.6+**, one self-contained module (`TSVZ.py`): drop it
 next to your code and `import TSVZ`, or install it.
 
 ```bash
@@ -224,6 +224,7 @@ delimiter or encoding argument that conflicts with the extension.
 | L4 | New warnings on stderr (invalid encoding, lines dropped by `strict`); data unchanged. |
 | L5 | A damaged compressed file is read up to the damage instead of raising. |
 | L6 | `mapToFile` no longer glues a row it adds at the end of the file to the next one. |
+| L7 | `TSVZed`'s `in` and `get` find a key as `t[key]` does: the live key equal to it, else the key right-stripped. 3.39 matched them exactly, so `'x ' in t` was false while `t['x ']` read `x`, and `t.setdefault('x ', …)` overwrote `x`. |
 
 ### `.tsvz`, `.csvz`, `.nsvz`, `.psvz`: now tsvz-spec-v1
 
@@ -243,6 +244,7 @@ delimiter or encoding argument that conflicts with the extension.
 | S12 | `TSVZedLite.clear()` and `clear_file()` raise `OSError` when the clear is refused (a part could not be read, the path names one part of a store, or the store kept changing). Memory is reloaded from the unchanged store first. |
 | S13 | Compressed parts are written in members of at most 1 MiB of records (`#_member_size_#`), Zstandard frames with a checksum; an append never reads or repairs the part. |
 | S14 | A zero byte in a value is written `<NUL>`, and a raw zero byte in a record is read as zero-fill damage (spec §4.9): under the default `recover` only the bytes after it are read. **A value that 4.2 or 4.3 wrote with a raw zero byte therefore reads differently in 4.4.** Such values are rare; before upgrading, `grep -c -P '\x00' store.tsvz` (any `.tsvz`, `.csvz` or `.psvz` part) finds them. Stop 4.2 and 4.3 handlers before upgrading: they read `<NUL>` as text, as they read `<CR>`. |
+| S15 | A lookup (`t[key]`, `in`, `get`, `del`, `pop`, `setdefault`) takes the live key equal to the one given before the right-stripped one, so a key ending in whitespace (written while `#_strip_trailing_whites_#` was false) can be read and deleted by name (spec §20.2.7). Setting a key still right-strips it. |
 
 ### The `tsvz` command
 
@@ -256,12 +258,13 @@ and `-d=,`, except the ones C5 and C9 list.
 | C3 | `read` and `scrub` of a missing store exit 1 with a message (3.39: exit 0, and `read` printed "File not found" on stdout). |
 | C4 | `delete` deletes every KEY it is given (3.39: only the first). |
 | C5 | `append` or `delete` without a KEY, or with an empty KEY, is a usage error with exit 2 (3.39 wrote an empty line). |
-| C6 | A `clear` or `scrub` that writes nothing (one part of a multi-part store, a store that kept changing) exits 1. |
+| C6 | A `clear` or `scrub` that writes nothing (one part of a multi-part store, a store that kept changing, a part that declares a spec version newer than 1, per spec §19.4 and §19.8) exits 1. |
 | C7 | `-c/--header`, `--defaults`, `-s/--strict` and `-f/--force` are undocumented aliases of the `--x-` options. `--x-header` and `--x-defaults` keep non-ASCII text. |
 | C8 | Usage errors print tsvz's own message, exit 2; the `-h` text is new. |
 | C9 | Arguments after STORE for `read`, `clear` and `scrub` are a usage error, exit 2 (3.39 ignored them, so `clear junk` cleared the file). |
 | C10 | The table (a terminal, or `--format table`) of `get`, `keys`, `pop`, `popitem`, `setdefault`, and of `read` on a `.tsvz`-family store, shows the rows only: no row is drawn as a header, and no row is cut to the first row's or the terminal's width. `read` of a `.tsv`-family file keeps 3.39's table, whose first row is the file's header line. |
 | C11 | The table shows control characters, bidi controls and line separators as escapes (`\r`, `\n`, `\t`, `\xNN`, `\uNNNN`), so no value can move the cursor, reorder the line or restyle the terminal. It sizes columns in terminal columns, so CJK text (two columns a character) lines up. The table is for reading: a backslash in a value is shown as is, so use records for exact values. |
+| C12 | While stripping is on, `get`, `has`, `pop`, `delete` and `setdefault` take the live key equal to a KEY ending in a space or tab before the stripped one (spec §20.2.7), so `tsvz keys s \| tsvz delete s -` deletes every key. `delete` of such a KEY reads the store first, and exits 1 without writing when the store cannot be read whole. |
 
 ## Spec deviations and interpretations
 

{tsvz-4.6 → tsvz-4.8}/TSVZ.py

@@ -40,10 +40,10 @@ if os.name == 'nt':
 elif os.name == 'posix':
 	import fcntl
 
-version = '4.6'
+version = '4.8'
 __version__ = version
 author = 'pan@zopyr.us'
-COMMIT_DATE = '2026-10-12'
+COMMIT_DATE = '2026-10-14'
 
 DEFAULT_DELIMITER = '\t'
 DEFAULTS_INDICATOR_KEY = '#_defaults_#'
@@ -1605,8 +1605,10 @@ def scrubTabularFile(fileName,teeLogger = None,header = '',createIfNotExist = Fa
 # ===========================================================================
 MAX_SPEC_VERSION = 1
 _MARKER_RE = re.compile(r'^#_[A-Za-z0-9_-]+_#$')
+#: What a lookup gets for a key that is not live (spec §20.2.7: then the stripped key is tried).
+_NO_ROW = object()
 _CHECKSUM_RE = re.compile(r'^#_checksum_([A-Za-z0-9_-]+)_#$', re.IGNORECASE)
-_ASCII_DIGITS_RE = re.compile(r'^[0-9]+$')
+_ASCII_DIGITS_RE = re.compile(r'^[0-9]+\Z')  # \Z: '$' would also match before a final newline
 _SPEC_DECODE_RE = re.compile(r'<(?:sep|LF|CR|NUL|lt|#)>')
 _SPEC_TOKENS = {'<LF>': '\n', '<CR>': '\r', '<NUL>': '\0', '<lt>': '<', '<#>': '#'}
 _RowState = namedtuple('_RowState', 'defaults strip fillEmpty')
@@ -1669,8 +1671,7 @@ def _specTombstones(keys, delimiter, strip):
 	(spec §9.6).
 	"""
 	rows = [([key], False) for key in keys]
-	if strip and any(key.endswith((' ', '\t')) and _specEncodeField(key, delimiter, isKey=True).endswith((' ', '\t'))
-					 for key in keys):
+	if strip and any(_specStrippable(key, delimiter) for key in keys):
 		rows.insert(0, (['#_strip_trailing_whites_#', 'false'], True))
 		rows.append((['#_strip_trailing_whites_#', 'true'], True))
 	return rows
@@ -1687,11 +1688,61 @@ def _specTombstoneLines(key, delimiter, strip):
 					 for cells, marker in _specTombstones([key], delimiter, strip))
 
 
+def _specStrippable(key, delimiter):
+	"""True when a reader that strips (spec §7.7) would change ``key``: its encoded form ends in a space or tab."""
+	return key.endswith((' ', '\t')) and _specEncodeField(key, delimiter, isKey=True).endswith((' ', '\t'))
+
+
+def _specNameKey(key, delimiter, strip, live):
+	"""The key that a requested ``key`` names (spec §20.2.7) in a store whose stripping is ``strip``.
+
+	While stripping is on, a key a reader would strip names the live key equal
+	to it (``live`` holds the live keys), else the key a reader resolves it to.
+	"""
+	if not strip or key in live or not _specStrippable(key, delimiter):
+		return key
+	return _specDecodeField(_specEncodeField(key, delimiter, isKey=True).rstrip(' \t'), delimiter)
+
+
+def _specNamesKeys(rows, delimiter):
+	"""True when naming the keys of ``delete`` rows (``[(cells, marker), ...]``) needs the store (spec §20.2.7)."""
+	return any(not marker and _specStrippable(cells[0], delimiter) for cells, marker in rows)
+
+
+def _specDeleteRows(rows, delimiter, strip, live):
+	"""The batch ``delete`` appends for ``rows`` (``[(cells, marker), ...]``, spec §20.2, §20.3).
+
+	Every key names a key of the store as it was before the batch, whose
+	stripping was ``strip`` and whose live keys are ``live`` (§20.2.7). The
+	tombstone of a key a reader would strip is written with stripping off
+	(§9.6). A reset of ``#_strip_trailing_whites_#`` in the batch turns
+	stripping back on (§10.3, §12.1).
+	"""
+	batch = []
+	named = strip
+	guarded = False
+	for cells, marker in rows:
+		if marker:
+			if cells[0].lower() == '#_strip_trailing_whites_#':
+				strip, guarded = True, False
+			batch.append((cells, marker))
+			continue
+		key = _specNameKey(cells[0], delimiter, named, live)
+		if strip and not guarded and _specStrippable(key, delimiter):
+			batch.append((['#_strip_trailing_whites_#', 'false'], True))
+			guarded = True
+		batch.append(([key], False))
+	if guarded:
+		batch.append((['#_strip_trailing_whites_#', 'true'], True))
+	return batch
+
+
 class _SpecState(object):
 	"""Reader state of spec §12, carried across records and parts."""
 
 	def __init__(self, defaults=None):
 		self.version = 1
+		self.newestVersion = 1  # the highest version a #_version_# line declared (spec §19.4, §19.8)
 		self.defaults = list(defaults) if defaults and len(defaults) > 1 else [DEFAULTS_INDICATOR_KEY]
 		self.strip = True
 		self.fillEmpty = False
@@ -1736,16 +1787,17 @@ def _specApplyMarker(state, keyLower, values, reporter, where):
 		else:
 			number = 0
 			if _ASCII_DIGITS_RE.match(value):
-				try:
-					number = int(value)
-				except ValueError:  # more digits than int() converts (Python 3.11+ limit)
-					pass
+				digits = value.lstrip('0') or '0'
+				# int() refuses very long values (Python 3.11+); any such value is above every implemented version.
+				number = int(digits) if len(digits) <= 64 else MAX_SPEC_VERSION + 1
 			if number < 1:
 				reporter.note('bad-marker', where, 'ignored #_version_# with invalid value {!r}'.format(value))
 				return False
 			if number > MAX_SPEC_VERSION:
-				reporter.note('newer-version', where, 'declares spec version {}; read as version {}'.format(value, MAX_SPEC_VERSION))
+				shown = value if len(value) <= 20 else '{}… ({} digits)'.format(value[:20], len(value))
+				reporter.note('newer-version', where, 'declares spec version {}; read as version {}'.format(shown, MAX_SPEC_VERSION))
 			state.version = number
+			state.newestVersion = max(state.newestVersion, number)
 	elif keyLower in _BOOL_MARKERS:
 		attr, default = _BOOL_MARKERS[keyLower]
 		if not value:
@@ -2990,7 +3042,8 @@ def _specClearTabularFile(fileName, teeLogger=None, header='', verifyHeader=Fals
 	A single file is read without a lock and rewritten in place only if no
 	other writer changed it since the read (else it is read again, up to
 	``_SPEC_REWRITE_ATTEMPTS`` times). A path naming one part of a multi-part
-	store is refused.
+	store is refused, and so is a single file declaring a spec version newer
+	than ``MAX_SPEC_VERSION``.
 	"""
 	reporter = _Reporter(fileName, teeLogger)
 	attempt = None
@@ -3024,6 +3077,10 @@ def _specClearTabularFile(fileName, teeLogger=None, header='', verifyHeader=Fals
 				break
 			if stamp is None or load.parts != parts:
 				continue  # the set of parts changed under the read
+			if load.state.newestVersion > MAX_SPEC_VERSION:
+				attempt.note('refused', None, 'clear skipped: the part declares a spec version newer than {} (#_version_#), whose '
+							 'markers this TSVZ cannot keep (spec §19.8); nothing was written'.format(MAX_SPEC_VERSION))
+				return False
 			if any(header) and verifyHeader and load.headerLine is not None and not headerChecked:
 				headerChecked = True
 				if not _lineContainHeader(header, load.headerLine[1:], verbose=verbose, teeLogger=teeLogger, strict=strict, delimiter=delimiter):
@@ -3106,8 +3163,8 @@ def _specScrub(fileName, teeLogger=None, header='', createIfNotExist=False, veri
 	writer changed it since the read (else it is read again, up to
 	``_SPEC_REWRITE_ATTEMPTS`` times), so a record committed meanwhile is
 	never compacted away. ``done`` is False when nothing was written because
-	the store is missing, has several parts (or the path names one part), or
-	kept changing. It is None when the read stopped at damaged data (spec
+	the store is missing, has several parts (or the path names one part),
+	declares a spec version newer than ``MAX_SPEC_VERSION``, or kept changing. It is None when the read stopped at damaged data (spec
 	§4.10): the part was rewritten from what was read, the original kept.
 	"""
 	if taskDic is None:
@@ -3143,6 +3200,11 @@ def _specScrub(fileName, teeLogger=None, header='', createIfNotExist=False, veri
 				return taskDic, False
 			if stamp is None or load.parts != parts:
 				continue  # the set of parts changed under the read
+			if load.state.newestVersion > MAX_SPEC_VERSION:
+				attempt.note('refused', None, 'scrub skipped: the store declares a spec version newer than {0} (#_version_#), which '
+							 'this TSVZ reads as version {0} only (spec §6.3); a rewrite would make that reading permanent; '
+							 'nothing was written'.format(MAX_SPEC_VERSION))
+				return taskDic, False
 			info = load.infos[0]
 			if (info.lost or info.damaged) and backedUp != stamp:
 				# Damaged data is not in what is written, or only unverified (spec §4.10, §16.6): keep the original
@@ -3628,14 +3690,37 @@ class TSVZed(OrderedDict):
 		# else:
 		#     self.appendEvent.set()
 
+	def _nameKey(self, key):
+		"""The key a requested ``key`` names: the live key equal to it, else ``key`` right-stripped (spec §20.2.7).
+
+		The fallback strips every trailing whitespace whatever the stripping
+		marker says, as ``__setitem__`` strips every key it writes.
+		"""
+		key = str(key)
+		return key if OrderedDict.__contains__(self, key) else key.rstrip()
+
 	def __getitem__(self, key):
-		return super().__getitem__(str(key).rstrip())
-		
+		key = str(key)
+		row = dict.get(self, key, _NO_ROW)  # one probe for the usual hit
+		return row if row is not _NO_ROW else OrderedDict.__getitem__(self, key.rstrip())
+
+	def __contains__(self, key):
+		# OrderedDict.setdefault asks this before it reads or writes, so it names keys as t[key] does.
+		key = str(key)
+		return dict.__contains__(self, key) or dict.__contains__(self, key.rstrip())
+
+	def get(self, key, default=None):
+		key = str(key)
+		row = dict.get(self, key, _NO_ROW)
+		if row is _NO_ROW:
+			row = dict.get(self, key.rstrip(), _NO_ROW)
+		return default if row is _NO_ROW else row
+
 
 	def __delitem__(self,key):
 		if self._spec:
 			return self._specDelItem(key)
-		key = str(key).rstrip()
+		key = self._nameKey(key)
 		if key == DEFAULTS_INDICATOR_KEY:
 			self.defaults = [DEFAULTS_INDICATOR_KEY]
 			if self.verbose:
@@ -3739,7 +3824,7 @@ class TSVZed(OrderedDict):
 		self.lastUpdateTime = get_time_ns()
 
 	def _specDelItem(self, key):
-		key = str(key).rstrip()
+		key = self._nameKey(key)
 		if _MARKER_RE.match(key):
 			# A lone marker key resets that marker (spec §12.1).
 			self._specSetMarker(key, [key])
@@ -3914,12 +3999,14 @@ memoryOnly:{self.memoryOnly}
 		is raised.
 
 		'''
-		key = str(key).rstrip()
-		if key not in self:
+		key = self._nameKey(key)
+		if not OrderedDict.__contains__(self, key):
 			if default is self.__marker:
 				raise KeyError(key)
 			return default
-		value = super().pop(key)
+		# Not OrderedDict.pop: before Python 3.11 it goes through del self[key], which writes a tombstone too.
+		value = OrderedDict.__getitem__(self, key)
+		OrderedDict.__delitem__(self, key)
 		if not self.memoryOnly:
 			self.__appendEmptyLine(key)
 		self.lastUpdateTime = get_time_ns()
@@ -3929,7 +4016,7 @@ memoryOnly:{self.memoryOnly}
 		'''Move an existing element to the end (or beginning if last is false).
 		Raise KeyError if the element does not exist.
 		'''
-		key = str(key).rstrip()
+		key = self._nameKey(key)
 		super().move_to_end(key, last)
 		if self._spec:
 			_warnOnce(self, 'move_to_end', self._fileName,
@@ -4452,9 +4539,18 @@ class TSVZedLite(MutableMapping):
 		"""'tsvz' for tsvz-spec-v1 files (.tsvz/.csvz/.nsvz/.psvz), 'tsv' for 3.39-format files."""
 		return 'tsvz' if self._spec else 'tsv'
 
+	def _nameKey(self, key):
+		"""The key a requested ``key`` names: the live key equal to it, else ``key`` right-stripped (spec §20.2.7).
+
+		The fallback strips every trailing whitespace whatever the stripping
+		marker says, as ``__setitem__`` strips every key it writes.
+		"""
+		key = str(key)
+		return key if key in self.indexes else key.rstrip()
+
 	def __contains__(self, key):
 		if self._spec:
-			return str(key).rstrip() in self.indexes
+			return self._nameKey(key) in self.indexes
 		return MutableMapping.__contains__(self, key)
 
 	def get(self, key, default=None):
@@ -4832,7 +4928,7 @@ class TSVZedLite(MutableMapping):
 
 	# Implement basic __getitem__, __setitem__, __delitem__, __iter__, and __len__. needed for MutableMapping
 	def __getitem__(self,key):
-		key = str(key).rstrip()
+		key = self._nameKey(key)
 		if key not in self.indexes:
 			if key == DEFAULTS_INDICATOR_KEY:
 				return self.defaults
@@ -4911,7 +5007,7 @@ class TSVZedLite(MutableMapping):
 		self.indexes[key] = self.__writeValues(value)
 		
 	def __delitem__(self,key):
-		key = str(key).rstrip()
+		key = self._nameKey(key)
 		if self._spec:
 			if _MARKER_RE.match(key):
 				# A lone marker key resets that marker (spec §12.1).
@@ -4969,7 +5065,7 @@ class TSVZedLite(MutableMapping):
 
 	__marker = object()
 	def pop(self, key, default=__marker, return_pos = False):
-		key = str(key).rstrip()
+		key = self._nameKey(key)
 		try:
 			pos = self.indexes.pop(key)
 		except KeyError:
@@ -5430,9 +5526,9 @@ class _ServeStore(object):
 			return not self.parts
 
 	def resolve(self, key):
-		"""A requested key as a reader resolves it (spec §7.7; 3.39 rstrip for loose files)."""
+		"""The key a requested key names (spec §20.2.7; 3.39 rstrip for loose files)."""
 		if self.spec:
-			return key.rstrip(' \t') if self.state.strip else key
+			return _specNameKey(key, self.delimiter, self.state.strip, self.data)
 		return key.rstrip()
 
 	def read(self, log):
@@ -5528,11 +5624,28 @@ class _ServeStore(object):
 			self.writer.wait(queued[0])
 
 	def write(self, rows, sync, log, written=False):
-		"""Append ``rows`` (``[(cells, marker), ...]``) as one batch: ``set``, ``delete`` and bulk input."""
+		"""Append ``rows`` (``[(cells, marker), ...]``) as one batch: ``set`` and its bulk input."""
 		with self.lock:
 			queued = self._submit(rows, sync, log)
 		self._ack(queued, written)
 
+	def delete(self, rows, sync, log, written=False):
+		"""Append the tombstones of ``delete`` (``[(cells, marker), ...]``) as one batch (spec §20.2.7).
+
+		Naming a key a reader would strip needs the store as it is now, read
+		under the lock, so that delete is atomic (spec §21.8.2). Returns False,
+		having written nothing, when that read could not be completed.
+		"""
+		with self.lock:
+			if self.spec and _specNamesKeys(rows, self.delimiter):
+				self._fresh(log)
+				if self.unreadable:
+					return False
+				rows = _specDeleteRows(rows, self.delimiter, self.state.strip, self.data)
+			queued = self._submit(rows, sync, log)
+		self._ack(queued, written)
+		return True
+
 	def pop(self, key, sync, log):
 		"""Atomically return the row of ``key`` and append its tombstone; None when it is missing."""
 		with self.lock:
@@ -5781,7 +5894,10 @@ def _serveDispatch(store, line, bulk, log):
 			rows = [([key], bool(_MARKER_RE.match(field))) for key, field in zip(args, raw)]
 		else:
 			rows = [(args, bool(_MARKER_RE.match(raw[0])))]
-		store.write(rows, sync, log, written)
+		if not keysOnly:
+			store.write(rows, sync, log, written)
+		elif not store.delete(rows, sync, log, written):
+			return 1, [], _SERVE_UNREADABLE + '; nothing was written'
 		return 0, [], ''
 	if operation in ('pop', 'popitem'):
 		if operation == 'pop':
@@ -6482,7 +6598,10 @@ class TSVZClient(MutableMapping):
 
 	def __delitem__(self, key):
 		"""Delete ``key``; a missing key is not an error (as in ``TSVZed``)."""
-		self._request(['delete', _serveEncode(str(key))], write=True)
+		key = str(key)
+		# Resending the delete of a key ending in whitespace could name, and delete, the stripped key (spec §20.2.7).
+		retry = not (self._spec and _specStrippable(key, self.delimiter))
+		self._request(['delete', _serveEncode(key)], write=True, retry=retry)
 
 	_marker = object()
 
@@ -6508,6 +6627,11 @@ class TSVZClient(MutableMapping):
 		cells = self._cells(key, default)
 		if len(cells) < 2:
 			return self.get(key)
+		if str(key) != cells[0]:
+			# cells[0] is stripped as set strips it; a live key equal to ``key`` wins first (spec §20.2.7).
+			row = self.get(key)
+			if row is not None:
+				return row
 		lines = self._request(['setdefault'] + self._fields(cells), write=True, retry=False)[0]
 		return _serveDecodeLine(lines[0]) if lines else None
 
@@ -6953,7 +7077,7 @@ def _cliRead(args, delimiter, logger, stdin, stdout):
 def _cliGet(args, delimiter, logger, stdin, stdout):
 	"""``get STORE KEY ...`` (spec §20.2): each KEY's row in argument order; exit 3 when one is missing.
 
-	Keys resolve as a reader resolves them (§7.7). For a missing key of a
+	Each KEY names a key as §20.2.7 says. For a missing key of a
 	spec store this prints what ``TSVZed`` returns for it (§14.5): the key and
 	the active defaults while ``#_return_defaults_when_missing_#`` is true,
 	else nothing. A missing key of a loose file prints nothing.
@@ -6972,7 +7096,7 @@ def _cliGet(args, delimiter, logger, stdin, stdout):
 	missing = False
 	for key in args.args:
 		if spec:
-			key = key.rstrip(' \t') if state.strip else key
+			key = _specNameKey(key, delimiter, state.strip, data)
 		else:
 			key = key.rstrip()
 		row = data.get(key)
@@ -7018,15 +7142,20 @@ def _cliStdinBatch(args, delimiter, logger, stdin, keysOnly):
 	so is a line with an empty key (reported). ``keysOnly`` keeps the first
 	field only: a tombstone, or a marker reset.
 	"""
-	spec = _isSpecPath(args.store)
+	rows = _cliStdinRows(args, delimiter, logger, stdin, keysOnly)
+	if not _isSpecPath(args.store):
+		return [cells for cells, marker in rows]
+	return [_specFormatRecord(cells, delimiter, marker=marker) for cells, marker in rows]
+
+
+def _cliStdinRows(args, delimiter, logger, stdin, keysOnly):
+	"""Standard input for ``set STORE -`` / ``delete STORE -`` as ``[(cells, marker), ...]`` (spec §20.3)."""
 	source = _Reporter('<stdin>', logger)
 	try:
-		rows = _parseRecordLines(_cliStdinLines(stdin, source), delimiter, spec, keysOnly, source)
+		return _parseRecordLines(_cliStdinLines(stdin, source), delimiter, _isSpecPath(args.store), keysOnly,
+								 source)
 	finally:
 		source.flush()
-	if not spec:
-		return [cells for cells, marker in rows]
-	return [_specFormatRecord(cells, delimiter, marker=marker) for cells, marker in rows]
 
 
 def _parseRecordLines(texts, delimiter, spec, keysOnly, reporter):
@@ -7091,12 +7220,33 @@ def _cliDelete(args, delimiter, logger, stdin, stdout):
 	"""``delete STORE KEY [KEY ...]`` (spec §20.2): one tombstone per KEY, appended in one write.
 
 	``delete STORE -`` deletes the first field of every line on standard input (§20.3).
+	A key that a reader would strip names a key of the store (§20.2.7), so the
+	store is read first; when it cannot be read whole nothing is written and
+	the exit status is 1.
 	"""
-	if args.args == ['-']:
-		_cliAppendBatch(args, delimiter, logger, _cliStdinBatch(args, delimiter, logger, stdin, keysOnly=True))
+	if not _isSpecPath(args.store):
+		if args.args == ['-']:
+			_cliAppendBatch(args, delimiter, logger, _cliStdinBatch(args, delimiter, logger, stdin, keysOnly=True))
+		else:
+			appendLinesTabularFile(args.store, [[key] for key in args.args], teeLogger=logger, header=args.header,
+								   createIfNotExist=True, verbose=args.verbose, strict=args.strict,
+								   delimiter=delimiter)
 		return _cliWritten(args, logger)
-	appendLinesTabularFile(args.store, [[key] for key in args.args], teeLogger=logger, header=args.header,
-						   createIfNotExist=True, verbose=args.verbose, strict=args.strict, delimiter=delimiter)
+	if args.args == ['-']:
+		rows = _cliStdinRows(args, delimiter, logger, stdin, keysOnly=True)
+	else:
+		rows = [([key], bool(_MARKER_RE.match(key))) for key in args.args]
+	if _specNamesKeys(rows, delimiter):
+		strip, live = True, {}  # a store delete creates starts with stripping on (spec §10.3)
+		if _cliStoreExists(args.store):
+			load, readable = _cliSpecLoad(args, delimiter, logger)
+			if not readable:
+				logger.teelog('tsvz: {}: could not read every part of the store; nothing was written'.format(
+					args.store), 'error')
+				return 1
+			strip, live = load.state.strip, load.data
+		rows = _specDeleteRows(rows, delimiter, strip, live)
+	_cliAppendBatch(args, delimiter, logger, [_specFormatRecord(cells, delimiter, marker=marker) for cells, marker in rows])
 	return _cliWritten(args, logger)