docs: trim the conformance test's prose

148 lines to 114. The module docstring restated what the testbed's own
README says, and the capability comments restated rules the TCK owns.

No behaviour change.

Author: aepfli

tests/test_provider_conformance.py

@@ -1,24 +1,13 @@
-"""The OpenFeature Provider Conformance Suite against this provider.
+"""The OpenFeature Provider Conformance Suite (Appendix F) against this provider.
 
-The suite is Appendix F of the OpenFeature specification: the same Gherkin scenarios, against the
-same canonical flag set, that every other language's provider TCK runs. See
-https://github.com/open-feature/spec/issues/417.
+Opt-in: `openfeature-tck` is not on PyPI yet, so this skips unless it is installed from
+`open-feature/python-sdk-contrib` (`tools/openfeature-tck`, with its `compose` extra)::
 
-**This module skips unless the TCK is installed.** `openfeature-tck` is not on PyPI yet -- it
-currently lives in `open-feature/python-sdk-contrib` under `tools/openfeature-tck`. So the suite is
-opt-in rather than part of the default `pytest` run:
-
-    pip install -e /path/to/python-sdk-contrib/tools/openfeature-tck
     pytest tests/test_provider_conformance.py
 
-It skips cleanly otherwise, so it costs the normal test run nothing.
-
-The backend is a container described by `tests/tck/docker-compose.yaml`. It, and how the four
-language adoptions compare against it, are documented once in
-https://github.com/aepfli/flagsmith-tck-testbed rather than restated in each adoption.
+Backend and cross-language results: https://github.com/aepfli/flagsmith-tck-testbed
 
-Results at the time of writing: **29 passed, 11 failed, 25 skipped**. The deviations below say
-which failures are defects in this provider and which are the backend's type system.
+Current: 29 passed, 11 failed, 25 skipped.
 """
 
 from __future__ import annotations
@@ -73,34 +62,20 @@ def tck_config(tck_backend: RunningBackend) -> TckConfig:
 
     def new_provider() -> FlagsmithProvider:
         client = Flagsmith(environment_key=SERVER_SIDE_KEY, api_url=base_url)
-        # use_boolean_config_value=True is required for the canonical flag set, and the reason is
-        # worth recording.
-        #
-        # This provider defaults to resolving a boolean flag from Flagsmith's `enabled` state, with
-        # feature_state_value as the opt-in. The Go and Java providers default the other way round.
-        # Four providers for one product, split two-two on what a boolean flag *is* -- JavaScript
-        # shares this default, Go and Java do not.
-        #
-        # The canonical set models booleans as values, so the default would resolve
-        # boolean-zero-flag to True, which the falsy-value scenario exists to catch.
+        # Default is False, which resolves a boolean from `enabled` rather than
+        # feature_state_value -- JavaScript's default too, and the opposite of Go and Java. The
+        # canonical set models booleans as values.
         return FlagsmithProvider(client, use_boolean_config_value=True)
 
     return TckConfig(
         name="flagsmith-python-remote",
         control=tck_backend.control,
         new_provider=new_provider,
-        # Capability.VARIANTS is withheld: Flagsmith has no variant concept for a plain feature,
-        # the evaluation response carries no variant key, and no seeding can produce one. That is
-        # permitted rather than defective -- 2.2.4 makes populating the variant a SHOULD and
-        # types.md marks the field optional -- so it carries no deviation entry.
+        # Withheld, permitted rather than defective, so no deviation: VARIANTS (Flagsmith names no
+        # value) and the lifecycle/event tags (no observable initialisation).
         #
-        # The lifecycle and event capabilities are withheld because this provider implements no
-        # initialize/shutdown lifecycle the suite can assert against. Declaring them would make
-        # those scenarios pass without the provider having done anything, and a vacuous pass is
-        # worse than a skip.
-        # DISABLED_FLAGS and NUMERIC_COERCION are declared and both fail: this provider attempts
-        # each and gets it wrong -- it raises GENERAL for a disabled flag, and type-checks a float
-        # that Flagsmith stores as a string.
+        # DISABLED_FLAGS and NUMERIC_COERCION are declared and both fail: the provider attempts
+        # each and gets it wrong.
         capabilities={
             Capability.OBJECT,
             Capability.LARGE_INTEGERS,
@@ -113,30 +88,21 @@ def new_provider() -> FlagsmithProvider:
                 capability=Capability.DISABLED_FLAGS,
                 issue="",
                 summary=(
-                    "A disabled flag raises FlagsmithProviderError with error code GENERAL rather "
-                    "than resolving to the caller default with no error code, so the scenario "
-                    "fails with GENERAL where it expects none. Neither configuration satisfies "
-                    "it: return_value_for_disabled_flags defaults to False and raises, and "
-                    "setting it True returns the configured value of the flag instead of the "
-                    "caller default, which the scenario also catches, because the configured "
-                    "value of each disabled flag differs from the default the scenario passes in. "
-                    "The Go and Java Flagsmith providers return the caller default with reason "
-                    "DISABLED and no error code, which is what the tag asserts, and both declare "
-                    "the capability. The JavaScript provider has the same defect as this one."
+                    "A disabled flag raises GENERAL rather than resolving to the caller default "
+                    "with no error code. Neither configuration satisfies the scenario: "
+                    "return_value_for_disabled_flags defaults to False and raises, and setting it "
+                    "True returns the configured value rather than the caller default, which the "
+                    "scenario also catches. Go and Java pass this; JavaScript has the same defect."
                 ),
             ),
             KnownDeviation(
                 capability=Capability.NUMERIC_COERCION,
                 issue="",
                 summary=(
-                    "Declared and failing rather than withheld, because the provider does have a float "
-                    "accessor and gets the answer wrong. Flagsmith has no "
-                    "float type -- feature_state_value is natively boolean, integer or string -- "
-                    "so every float is stored as a string, and _BASIC_FLAG_TYPE_MAPPINGS[FLOAT] "
-                    "is a plain isinstance check against `float`. A Flagsmith float therefore "
-                    "never satisfies it and get_float_details returns TYPE_MISMATCH, so reading a "
-                    "float back as a float does not work at all. The Go provider handles this by "
-                    "parsing the string in its Float accessor; this one does not."
+                    "Flagsmith stores floats as strings, and _BASIC_FLAG_TYPE_MAPPINGS[FLOAT] is a "
+                    "plain isinstance check against `float`, so a Flagsmith float never satisfies "
+                    "it and get_float_details returns TYPE_MISMATCH. Reading a float back as a "
+                    "float does not work at all. Go parses the stored string; this one does not."
                 ),
             ),
         ],