address review: float membership case + broaden _safe_membership docstring

- add a float right-operand assertion so the test matches its comment (was
  claiming float coverage while only exercising int/bool/None).
- reword the _safe_membership docstring to describe TypeError generally
  (non-iterable right is the common case, but also e.g. an unhashable left
  against a set) rather than implying only the right operand matters.

Author: Quratulain-bilal

src/specify_cli/workflows/expressions.py

@@ -514,13 +514,15 @@ def _coerce_number(value: Any) -> Any:
 def _safe_membership(left: Any, right: Any, *, negate: bool) -> bool:
     """Safely evaluate ``left in right`` (or ``not in``) without crashing.
 
-    A non-iterable right operand (``None``, an int, a bool, ...) makes ``in``
-    raise ``TypeError`` in Python. Nothing is contained in such a value, so
-    treat membership as ``False`` (``not in`` as ``True``) rather than leaking
-    the error out of the evaluator and crashing the whole workflow. Mirrors the
-    graceful ``TypeError`` handling in ``_safe_compare`` for the ordering
-    operators, and generalizes the previous ``right is not None`` guard to
-    every non-iterable right operand.
+    ``left in right`` raises ``TypeError`` whenever the operands don't support
+    membership testing — most commonly a non-iterable right operand (``None``,
+    an int, a bool), but also cases like an unhashable ``left`` against a set.
+    In every such case the membership relation is undefined, so treat it as
+    ``False`` (``not in`` as ``True``) rather than leaking the error out of the
+    evaluator and crashing the whole workflow. Mirrors the graceful
+    ``TypeError`` handling in ``_safe_compare`` for the ordering operators, and
+    generalizes the previous ``right is not None`` guard to any operand pair
+    that can't be membership-tested.
     """
     try:
         contained = left in right

tests/test_workflows.py

@@ -473,9 +473,10 @@ def test_membership_against_non_iterable_is_false_not_error(self):
         # TypeError and crashing the whole workflow run. This generalizes the
         # previous `right is not None` guard and mirrors _safe_compare, which
         # already swallows TypeError for the ordering operators.
-        ctx = StepContext(inputs={"tag": "x", "count": 5, "flag": True})
+        ctx = StepContext(inputs={"tag": "x", "count": 5, "ratio": 1.5, "flag": True})
         assert evaluate_expression("{{ inputs.tag in inputs.count }}", ctx) is False
         assert evaluate_expression("{{ inputs.tag not in inputs.count }}", ctx) is True
+        assert evaluate_expression("{{ 'a' in inputs.ratio }}", ctx) is False
         assert evaluate_expression("{{ 'a' in inputs.flag }}", ctx) is False
         assert evaluate_expression("{{ inputs.tag in inputs.missing }}", ctx) is False
         # A condition that would otherwise crash the run now evaluates cleanly.