Fix fastrun bugs, resolve TODOs and update the documentation

[LeMyst]

Summary

This PR fixes several long-standing bugs in wbi_fastrun.py, resolves the three TODOs of the module, and rewrites the outdated fast run section of the README. Every fix comes with a regression test; the offline test suite grows from 203 to 215 tests.

Bug fixes in write_required() / get_items()

• Append mode could silently skip a required write: a new value missing from the item was masked by another value matching two duplicate statements (len(comp) counted matching pairs, not matched statements). Each new statement must now individually exist on the item.
• FORCE_APPEND now always reports a write: previously, when all the submitted statements already existed, the forced append was silently skipped.
• case_insensitive mode crashed with an AttributeError (datavalue is a dict, not a string) and could never match values differing by case. The comparison is now handled by _statements_equal(), which compares string values casefolded together with qualifiers (and references when use_refs is enabled).
• Deletion objects (value-less claims) crashed get_items() with a KeyError: the skip condition used and where the intent (and the equivalent code in write_required()) was or.
• Quantity properties never matched: get_items() looked up the full SPARQL literal ("+42"^^xsd:decimal) while rev_lookup stores plain amounts (+42), so a write was always wrongly reported.
• Unitless quantities never matched: the RDF export represents a unitless quantity with the Wikidata Q199 entity whatever the instance (verified against WDQS), while the JSON representation uses '1'. The unit URIs are now normalized by a dedicated _normalize_unit() method, replacing the previous "dirty fix" that only covered non-Wikidata instances.

TODO resolutions

• Qualifier/reference reconstruction now supports every datatype: qualifiers and references are rebuilt with parse_sparql_value() instead of passing a generic value to constructors that do not all accept it (quantity qualifiers crashed with a TypeError).
• Time.parse_sparql_value() added: time values crashed the generic parsing path (Time.set_value() has no value parameter). The precision is inferred from the timestamp.
• Monolingual text qualifiers and references keep their language in format_query_results(), so they can be reconstructed and compared.
• The remaining limitation (attributes absent from the SPARQL simple values: time precision, globe coordinate precision, quantity bounds) is documented in the code and the README instead of a TODO.

Cleanups

• Remove the dead del_props handling and the unreachable FORCE_APPEND condition
• Raise a clear ValueError instead of an IndexError when no datatype class matches
• clear() also resets the language data cache
• Debug-only loops only run when DEBUG logging is enabled

Documentation

The "Examples (in fast run mode)" section of the README still documented the WikidataIntegrator API (fast_run=True, fast_run_base_filter as a dictionary, init_fastrun()). It is rewritten around the current API: entity.write_required() and its options, the three base filter forms (including property paths), the fact that only the claims whose property appears in the base filter are compared, label/description/aliases checking through the fastrun container, and the limitations.

Test plan

• pytest test/ — 215 passed (12 new regression tests)
• mypy — no issues on the modified files
• Unitless unit representation verified against the live Wikidata Query Service

🤖 Generated with Claude Code

[LeMyst]

Closing in favour of #333, which rewrites the fastrun implementation instead of patching the current one.

The decisive difference is architectural. This PR keeps _query_data(), which loads the whole corpus with a single paginated SPARQL query. That query is what repeatedly timed out (five consecutive WDQS 504s) on a real benchmark of only 95 entities, and it is the part that cannot scale to a larger corpus. #333 scopes its queries per statement instead, so each one stays small.

This PR also still carries the crash at wbi_fastrun.py:291: the list comprehension in that log.debug() call builds [z.mainsnak.datavalue for z in x.qualifiers], but iterating qualifiers yields Snaks, which expose .datavalue directly (lines 274-278 get this right). Since the list is built before the call, it raises an AttributeError even with debug logging disabled. #333 no longer has that code.

Everything worth keeping from this PR was compared against #333 and was already covered there: the clear ValueError on unknown datatypes, the Q199 unitless normalization, clear() resetting the language cache, FORCE_APPEND always requiring a write, the case-insensitive comparison fix, and lazy debug logging.

The one thing this PR still had over #333 was datatype coverage, through the generic parse_sparql_value() on BaseDataType. That has now been ported to #333 (commit Support every datatype in fastrun comparisons) as a generic from_sparql_value() for literal values, plus URI-specific implementations for Property, Lexeme, Form, Sense, GeoShape, TabularData and CommonsMedia. It also fixed a silent bug found on the way: CommonsMedia inherited the URL implementation, stored the whole Commons URL and could never match a local claim, without even emitting a warning.