TSVZ 4.5__tar.gz → 4.7__tar.gz

{tsvz-4.5 → tsvz-4.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: TSVZ
-Version: 4.5
+Version: 4.7
 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.5**, Python **3.6+**, one self-contained module (`TSVZ.py`): drop it
+**Version 4.7**, 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
 
@@ -262,6 +264,7 @@ and `-d=,`, except the ones C5 and C9 list.
 | 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.5 → tsvz-4.7}/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.5**, Python **3.6+**, one self-contained module (`TSVZ.py`): drop it
+**Version 4.7**, 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
 
@@ -235,6 +237,7 @@ and `-d=,`, except the ones C5 and C9 list.
 | 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.5 → tsvz-4.7}/TSVZ.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: TSVZ
-Version: 4.5
+Version: 4.7
 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.5**, Python **3.6+**, one self-contained module (`TSVZ.py`): drop it
+**Version 4.7**, 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
 
@@ -262,6 +264,7 @@ and `-d=,`, except the ones C5 and C9 list.
 | 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.5 → tsvz-4.7}/TSVZ.py

@@ -40,10 +40,10 @@ if os.name == 'nt':
 elif os.name == 'posix':
 	import fcntl
 
-version = '4.5'
+version = '4.7'
 __version__ = version
 author = 'pan@zopyr.us'
-COMMIT_DATE = '2026-10-12'
+COMMIT_DATE = '2026-10-13'
 
 DEFAULT_DELIMITER = '\t'
 DEFAULTS_INDICATOR_KEY = '#_defaults_#'
@@ -179,13 +179,18 @@ def get_terminal_size():
 	try:
 		import os
 		_tsize = os.get_terminal_size()
+		if not (_tsize[0] and _tsize[1]):
+			raise OSError('the terminal has no size set')
 	except Exception:
 		try:
 			import fcntl
 			import struct
 			import termios
 			packed = fcntl.ioctl(0, termios.TIOCGWINSZ, struct.pack('HHHH', 0, 0, 0, 0))
-			_tsize = struct.unpack('HHHH', packed)[:2]
+			rows, columns = struct.unpack('HHHH', packed)[:2]
+			if not (rows and columns):
+				raise OSError('the terminal has no size set')
+			_tsize = (columns, rows)
 		except Exception:
 			import shutil
 			_tsize = shutil.get_terminal_size(fallback=(240, 50))
@@ -1600,6 +1605,8 @@ 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]+$')
 _SPEC_DECODE_RE = re.compile(r'<(?:sep|LF|CR|NUL|lt|#)>')
@@ -1654,6 +1661,82 @@ def _specFormatRecord(cells, delimiter, marker=False):
 	return delimiter.join([first] + [_specEncodeField(cell, delimiter) for cell in cells[1:]])
 
 
+def _specTombstones(keys, delimiter, strip):
+	"""``(cells, marker)`` records that delete ``keys`` (spec §9.2) from a store whose stripping is ``strip``.
+
+	While stripping is on a reader strips a tombstone's key too (spec §9.1): the
+	tombstone of a key whose encoded form ends in a space or tab, stored while
+	stripping was off, would delete the stripped key instead. A batch holding
+	one is written with stripping off, and stripping is turned back on after it
+	(spec §9.6).
+	"""
+	rows = [([key], False) 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
+
+
+def _specFormatRecords(rows, delimiter):
+	"""``rows`` (``[(cells, marker), ...]``) as record lines, each with its '\\n'."""
+	return ''.join(_specFormatRecord(cells, delimiter, marker=marker) + '\n' for cells, marker in rows)
+
+
+def _specTombstoneLines(key, delimiter, strip):
+	"""The tombstone of ``key`` (spec §9.6) as lines joined by '\\n', without a last '\\n'."""
+	return '\n'.join(_specFormatRecord(cells, delimiter, marker=marker)
+					 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."""
 
@@ -2604,16 +2687,23 @@ def _specBackupPart(path, reporter):
 			_lockFile(f)
 			try:
 				first = backup = '{}.damaged-{}'.format(path, time.strftime('%Y%m%dT%H%M%S'))
+				# Readable by whoever could read the part, writable by its owner only, never setuid,
+				# setgid, sticky or executable (the umask still applies on top).
+				st = os.fstat(f.fileno())
+				mode = st.st_mode & 0o644
 				suffix = 0
 				while True:
 					try:
-						copy = open(backup, 'xb')  # never overwrite an earlier backup
+						# never overwrite an earlier backup; O_BINARY: no newline translation on Windows
+						flags = os.O_WRONLY | os.O_CREAT | os.O_EXCL | getattr(os, 'O_BINARY', 0)
+						copy = os.fdopen(os.open(backup, flags, mode), 'wb')
 						break
 					except FileExistsError:
 						suffix += 1
 						backup = '{}.{}'.format(first, suffix)
 				try:
 					with copy:
+						_matchOwner(copy.fileno(), st)
 						shutil.copyfileobj(f, copy)
 						copy.flush()
 						os.fsync(copy.fileno())
@@ -2672,6 +2762,22 @@ def _specSnapshot(fileName):
 		return parts, None
 
 
+def _matchOwner(fd, st):
+	"""Give a new copy the owner and group of the file ``st`` describes. Where that is not allowed,
+	a copy left in another group loses its group bits, so no one reads it who could not read the file."""
+	if not hasattr(os, 'fchown'):
+		return
+	for uid in (st.st_uid, -1):
+		try:
+			os.fchown(fd, uid, st.st_gid)
+			return
+		except OSError:
+			pass
+	created = os.fstat(fd)
+	if created.st_gid != st.st_gid:
+		os.fchmod(fd, created.st_mode & 0o7707)  # what the umask left, without the group bits
+
+
 def _specRewriteInPlace(path, content, expect=None, memberSize=None):
 	"""Replace a part's bytes in place (same inode, spec §18.7 / §19.8).
 
@@ -2691,18 +2797,73 @@ def _specRewriteInPlace(path, content, expect=None, memberSize=None):
 				st = os.fstat(f.fileno())
 				if expect is not None and _specStamp(st) != expect:
 					return None
-				if st.st_size == len(raw) and f.read() == raw:
+				fd = f.fileno()
+				# The whole part, for a failed rewrite to put back whenever it fails. Read unbuffered, as
+				# the file is written below: a read-ahead in f would leave it a stale position to close at.
+				old = _readFrom0(fd, st.st_size)
+				if old == raw:
 					return False
-				f.seek(0)
-				f.write(raw)
-				f.truncate()
-				f.flush()
-				os.fsync(f.fileno())
+				try:
+					_reserveSpace(fd, len(raw))  # spec §19.8: a full disk refuses the rewrite before any byte changes
+					_writeFrom0(fd, raw)
+				except BaseException as e:
+					# Put the old bytes back rather than leave a half-rewritten part (or one a failed
+					# reservation lengthened).
+					try:
+						_writeFrom0(fd, old)
+						os.fsync(fd)
+					except OSError as undo:
+						damaged = '{}: the rewrite failed ({!r}) and the old bytes could not be put back ({}): the part is damaged'.format(
+							path, e, undo)
+						if isinstance(e, OSError):
+							raise OSError(e.errno, damaged)
+						_warn('TSVZ warning: ' + damaged)  # an interrupt stays an interrupt
+					raise
+				os.fsync(fd)
 				return True
 			finally:
+				try:
+					_seekRawStart(f)  # msvcrt unlocks from the raw position: the range it locked
+				except OSError:
+					pass
 				_unlockFile(f)
 
 
+def _reserveSpace(fd, length):
+	"""Reserve ``length`` bytes from the start of the file before it is rewritten in place (spec
+	§19.8). Where the platform or the file system cannot reserve space, nothing is reserved."""
+	fallocate = getattr(os, 'posix_fallocate', None)
+	if fallocate is None or length <= 0:
+		return
+	try:
+		fallocate(fd, 0, length)
+	except OSError as e:
+		if e.errno not in (errno.EOPNOTSUPP, getattr(errno, 'ENOTSUP', errno.EOPNOTSUPP), errno.ENOSYS, errno.EINVAL):
+			raise
+
+
+def _readFrom0(fd, length):
+	"""Up to ``length`` bytes from the start of the file (unbuffered)."""
+	os.lseek(fd, 0, os.SEEK_SET)
+	chunks = []
+	while length > 0:
+		chunk = os.read(fd, length)
+		if not chunk:
+			break
+		chunks.append(chunk)
+		length -= len(chunk)
+	return b''.join(chunks)
+
+
+def _writeFrom0(fd, data):
+	"""Write ``data`` over the file from offset 0 and cut the file there (unbuffered)."""
+	os.lseek(fd, 0, os.SEEK_SET)
+	view = memoryview(data)
+	while view:
+		view = view[os.write(fd, view):]
+	os.ftruncate(fd, len(data))
+
+
 def _specPreamble(state, delimiter, compensate=False, version=True):
 	"""Marker lines that re-create ``state`` (spec §19.2.3a): version, non-default markers, defaults last.
 
@@ -2905,7 +3066,7 @@ def _specClearTabularFile(fileName, teeLogger=None, header='', verifyHeader=Fals
 				attempt.note('refused', None, 'clear skipped: a part of the store could not be read; nothing was written')
 				return False
 			if len(load.parts) > 1:
-				tombstones = ''.join(_specFormatRecord([key], delimiter) + '\n' for key in load.data)
+				tombstones = _specFormatRecords(_specTombstones(load.data, delimiter, load.state.strip), delimiter)
 				if tombstones:
 					_specAppendPayload(load.active, tombstones.encode('utf-8'), attempt, memberSize=load.state.memberSize)
 				attempt.note('multipart', None, 'cleared a multi-part store by appending tombstones; older parts are not compacted')
@@ -3517,14 +3678,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:
@@ -3558,8 +3742,8 @@ class TSVZed(OrderedDict):
 		# the mapping by the caller, so self[key] must not be accessed.
 		self.dirty = True
 		if self._spec:
-			# Spec §9.2: a tombstone is the lone key, never padded.
-			self.appendQueue.append(_specFormatRecord([key], self.delimiter))
+			# Spec §9.2: a tombstone is the lone key, never padded. One queue item, so it is committed whole.
+			self.appendQueue.append(_specTombstoneLines(key, self.delimiter, self._specState.strip))
 			return self
 		if self.correctColumnNum > 1:
 			emptyLine = [key]+['']*(self.correctColumnNum-1)
@@ -3628,7 +3812,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])
@@ -3781,7 +3965,15 @@ memoryOnly:{self.memoryOnly}
 		return self.close()
 
 	def popitem(self, last=True):
-		key, value = super().popitem(last)
+		if sys.version_info >= (3, 11):
+			key, value = OrderedDict.popitem(self, last)
+		else:
+			# Before Python 3.11 OrderedDict.popitem goes through self[key] and del self[key], which strip the key.
+			if not OrderedDict.__len__(self):
+				raise KeyError('dictionary is empty')
+			key = next(OrderedDict.__reversed__(self)) if last else next(OrderedDict.__iter__(self))
+			value = OrderedDict.__getitem__(self, key)
+			OrderedDict.__delitem__(self, key)
 		if not self.memoryOnly:
 			self.__appendEmptyLine(key)
 		self.lastUpdateTime = get_time_ns()
@@ -3795,12 +3987,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()
@@ -3810,7 +4004,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,
@@ -4333,9 +4527,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):
@@ -4486,7 +4689,7 @@ class TSVZedLite(MutableMapping):
 		self._specWrite(_specFormatRecord(value, self.delimiter, marker=True))
 
 	def _specWrite(self, line):
-		"""Append one record to the active part; return its offset, or None for a compressed part."""
+		"""Append one record (or lines written together) to the active part; return its offset, or None for a compressed part."""
 		data = (line + '\n').encode('utf-8', errors='replace')
 		if self.fileObj is None:
 			reporter = _Reporter(self._activePath)
@@ -4659,7 +4862,7 @@ class TSVZedLite(MutableMapping):
 
 	def __mapDeleteToFile(self,key):
 		if self._spec:
-			self._specWrite(_specFormatRecord([key], self.delimiter))
+			self._specWrite(_specTombstoneLines(key, self.delimiter, self._specState.strip))
 			return
 		# Persist a deletion by appending a tombstone (a lone key with no
 		# values); on read such a row deletes the key (see _processLine). The
@@ -4713,7 +4916,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
@@ -4792,7 +4995,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).
@@ -4803,7 +5006,7 @@ class TSVZedLite(MutableMapping):
 					eprint(f"Key {key} not found")
 				return
 			self.indexes.pop(key, None)
-			self._specWrite(_specFormatRecord([key], self.delimiter))
+			self.__mapDeleteToFile(key)
 			return
 		if key == DEFAULTS_INDICATOR_KEY:
 			self.__mapDeleteToFile(key)
@@ -4850,7 +5053,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:
@@ -5311,9 +5514,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):
@@ -5380,11 +5583,14 @@ class _ServeStore(object):
 	def _payload(self, rows, log):
 		"""Bytes for ``rows`` (``[(cells, marker), ...]``), formatted as the direct writers format them."""
 		if self.spec:
-			return ''.join(_specFormatRecord(cells, self.delimiter, marker=marker) + '\n'
-						   for cells, marker in rows).encode('utf-8')
+			return _specFormatRecords(rows, self.delimiter).encode('utf-8')
 		return _legacyFormatPayload(self.path, [cells for cells, marker in rows], log, [''], True, self.verbose,
 									'utf8', self.strict, self.delimiter)[0]
 
+	def _tombstone(self, key):
+		"""Rows that delete ``key``: written with stripping off when it would strip ``key`` (spec §9.6)."""
+		return _specTombstones([key], self.delimiter, self.state.strip) if self.spec else [([key], False)]
+
 	def _durable(self, sync):
 		return sync or (self.spec and self.state.writeAck == 'disk')
 
@@ -5406,10 +5612,27 @@ 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."""
@@ -5422,7 +5645,7 @@ class _ServeStore(object):
 			if row is None:
 				return None
 			row = list(row)
-			queued = self._submit([([key], False)], sync, log)
+			queued = self._submit(self._tombstone(key), sync, log)
 		self._ack(queued, written=True)  # the row is only popped once its tombstone is written
 		return row
 
@@ -5436,7 +5659,7 @@ class _ServeStore(object):
 				return None
 			key = next(reversed(self.data)) if last else next(iter(self.data))
 			row = list(self.data[key])
-			queued = self._submit([([key], False)], sync, log)
+			queued = self._submit(self._tombstone(key), sync, log)
 		self._ack(queued, written=True)
 		return row
 
@@ -5621,21 +5844,32 @@ def _serveDispatch(store, line, bulk, log):
 	if operation in _SERVE_NEED_STORE and store.missing(log):
 		return 1, [], 'no such store'  # spec §20.2.2
 	unreadable = (1, _SERVE_UNREADABLE)
+	# Each read takes its status under the store lock it read under: another request's reload may
+	# change ``unreadable`` once the lock is free.
 	if operation == 'read':
-		rows = store.read(log)
-		status = unreadable if store.unreadable else (0, '')
+		with store.lock:
+			rows = store.read(log)
+			status = unreadable if store.unreadable else (0, '')
 		return status[0], [_specFormatRecord(row, '\t') for row in rows], status[1]
 	if operation == 'get':
-		rows, missing = store.get(args, log)
-		status = unreadable if store.unreadable else (3 if missing else 0, '')
+		with store.lock:
+			rows, missing = store.get(args, log)
+			status = unreadable if store.unreadable else (3 if missing else 0, '')
 		return status[0], [_specFormatRecord(row, '\t') for row in rows], status[1]
 	if operation == 'has':
-		found = store.has(args[0], log)
-		return (1, [], _SERVE_UNREADABLE) if store.unreadable else (0 if found else 3, [], '')
+		with store.lock:
+			found = store.has(args[0], log)
+			return (1, [], _SERVE_UNREADABLE) if store.unreadable else (0 if found else 3, [], '')
 	if operation == 'len':
-		return 0, [str(store.length(log))], ''
+		with store.lock:
+			count = store.length(log)
+			status = unreadable if store.unreadable else (0, '')  # spec §4.10, §20.6: a stopped read failed
+		return status[0], [str(count)], status[1]
 	if operation == 'keys':
-		return 0, [_specEncodeField(key, '\t', isKey=True) for key in store.keys(log)], ''
+		with store.lock:
+			keys = store.keys(log)
+			status = unreadable if store.unreadable else (0, '')
+		return status[0], [_specEncodeField(key, '\t', isKey=True) for key in keys], status[1]
 	if operation in ('set', 'append', 'delete'):
 		keysOnly = operation == 'delete'
 		if isBulk:
@@ -5648,7 +5882,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':
@@ -6349,7 +6586,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()
 
@@ -6375,6 +6615,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
 
@@ -6820,7 +7065,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.
@@ -6839,7 +7084,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)
@@ -6885,15 +7130,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):
@@ -6958,12 +7208,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)