represent various objects when logging better

screenpy/actions/make_note.py

@@ -9,6 +9,7 @@
 from screenpy.exceptions import UnableToAct
 from screenpy.pacing import aside, beat
 from screenpy.protocols import Answerable, ErrorKeeper
+from screenpy.speech_tools import represent_prop
 
 SelfMakeNote = TypeVar("SelfMakeNote", bound="MakeNote")
 T_Q = Union[Answerable, object]
@@ -54,9 +55,9 @@ def as_(self: SelfMakeNote, key: str) -> SelfMakeNote:
 
     def describe(self: SelfMakeNote) -> str:
         """Describe the Action in present tense."""
-        return f"Make a note under {self.key}."
+        return f"Make a note under {represent_prop(self.key)}."
 
-    @beat('{} jots something down under "{key}".')
+    @beat("{} jots something down under {key_to_log}.")
     def perform_as(self: SelfMakeNote, the_actor: Actor) -> None:
         """Direct the Actor to take a note."""
         if self.key is None:
@@ -81,3 +82,4 @@ def __init__(
     ) -> None:
         self.question = question
         self.key = key
+        self.key_to_log = represent_prop(key)

screenpy/actions/see.py

@@ -9,7 +9,7 @@
 from screenpy.actor import Actor
 from screenpy.pacing import aside, beat
 from screenpy.protocols import Answerable, ErrorKeeper, Resolvable
-from screenpy.speech_tools import get_additive_description
+from screenpy.speech_tools import get_additive_description, represent_prop
 
 SelfSee = TypeVar("SelfSee", bound="See")
 T_Q = Union[Answerable, object]
@@ -56,7 +56,7 @@ def perform_as(self: SelfSee, the_actor: Actor) -> None:
         else:
             # must be a value instead of a question!
             value = self.question
-            aside(f"the actual value is: {value}")
+            aside(f"the actual value is: {represent_prop(value)}")
 
         reason = ""
         if isinstance(self.question, ErrorKeeper):

screenpy/pacing.py

@@ -9,6 +9,7 @@
 from typing import Any, Callable, Optional
 
 from screenpy.narration import Narrator, StdOutAdapter
+from screenpy.speech_tools import represent_prop
 
 Function = Callable[..., Any]
 the_narrator: Narrator = Narrator(adapters=[StdOutAdapter()])
@@ -88,7 +89,7 @@ def wrapper(*args: Any, **kwargs: Any) -> Any:
             with the_narrator.stating_a_beat(func, completed_line, gravitas) as n_func:
                 retval = n_func(*args, **kwargs)
                 if retval is not None:
-                    aside(f"=> {retval}")
+                    aside(f"=> {represent_prop(retval)}")
             return retval
 
         return wrapper

screenpy/resolutions/contains_the_entry.py

@@ -9,6 +9,7 @@
 
 from screenpy.exceptions import UnableToFormResolution
 from screenpy.pacing import beat
+from screenpy.speech_tools import represent_prop
 
 K = TypeVar("K", bound=Hashable)
 V = TypeVar("V")
@@ -78,4 +79,6 @@ def __init__(self, *kv_args: Any, **kv_kwargs: Any) -> None:
                 ]
                 self.entries = dict(pairs, **kv_kwargs)
         self.entry_plural = "entries" if len(self.entries) != 1 else "entry"
-        self.entries_to_log = ", ".join(f"{k}->{v}" for k, v in self.entries.items())
+        self.entries_to_log = ", ".join(
+            f"{represent_prop(k)}->{represent_prop(v)}" for k, v in self.entries.items()
+        )

screenpy/resolutions/contains_the_item.py

@@ -8,6 +8,7 @@
 from hamcrest.core.matcher import Matcher
 
 from screenpy.pacing import beat
+from screenpy.speech_tools import represent_prop
 
 T = TypeVar("T")
 
@@ -24,12 +25,13 @@ class ContainsTheItem:
 
     def describe(self) -> str:
         """Describe the Resolution's expectation."""
-        return f'A sequence containing "{self.item}".'
+        return f"A sequence containing {self.item_to_log}."
 
-    @beat('... hoping it contains "{item}".')
+    @beat("... hoping it contains {item_to_log}.")
     def resolve(self) -> Matcher[Sequence[T]]:
         """Produce the Matcher to make the assertion."""
         return has_item(self.item)
 
     def __init__(self, item: T) -> None:
         self.item = item
+        self.item_to_log = represent_prop(item)

screenpy/resolutions/contains_the_key.py

@@ -8,6 +8,7 @@
 from hamcrest.core.matcher import Matcher
 
 from screenpy.pacing import beat
+from screenpy.speech_tools import represent_prop
 
 K = TypeVar("K", bound=Hashable)
 
@@ -22,12 +23,13 @@ class ContainsTheKey(Generic[K]):
 
     def describe(self) -> str:
         """Describe the Resolution's expectation."""
-        return f'Containing the key "{self.key}".'
+        return f"Containing the key {self.key_to_log}."
 
-    @beat('... hoping it\'s a dict containing the key "{key}".')
+    @beat("... hoping it's a dict containing the key {key_to_log}.")
     def resolve(self) -> Matcher[Mapping[K, Any]]:
         """Produce the Matcher to make the assertion."""
         return has_key(self.key)
 
     def __init__(self, key: K) -> None:
         self.key = key
+        self.key_to_log = represent_prop(key)

screenpy/resolutions/contains_the_text.py

@@ -6,6 +6,7 @@
 from hamcrest.core.matcher import Matcher
 
 from screenpy.pacing import beat
+from screenpy.speech_tools import represent_prop
 
 
 class ContainsTheText:
@@ -20,12 +21,13 @@ class ContainsTheText:
 
     def describe(self) -> str:
         """Describe the Resolution's expectation."""
-        return f'Containing the text "{self.text}".'
+        return f"Containing the text {self.text_to_log}."
 
-    @beat('... hoping it contains "{text}".')
+    @beat("... hoping it contains {text_to_log}.")
     def resolve(self) -> Matcher[str]:
         """Produce the Matcher to make the assertion."""
         return contains_string(self.text)
 
     def __init__(self, text: str) -> None:
         self.text = text
+        self.text_to_log = represent_prop(text)

screenpy/resolutions/contains_the_value.py

@@ -8,6 +8,7 @@
 from hamcrest.core.matcher import Matcher
 
 from screenpy.pacing import beat
+from screenpy.speech_tools import represent_prop
 
 V = TypeVar("V")
 
@@ -24,12 +25,13 @@ class ContainsTheValue(Generic[V]):
 
     def describe(self) -> str:
         """Describe the Resolution's expectation."""
-        return f'Containing the value "{self.value}".'
+        return f"Containing the value {self.value_to_log}."
 
-    @beat('... hoping it contains the value "{value}".')
+    @beat("... hoping it contains the value {value_to_log}.")
     def resolve(self) -> Matcher[Mapping[Any, V]]:
         """Produce the Matcher to form the assertion."""
         return has_value(self.value)
 
     def __init__(self, value: V) -> None:
         self.value = value
+        self.value_to_log = represent_prop(value)

screenpy/resolutions/custom_matchers/sequence_containing_pattern.py

@@ -28,7 +28,7 @@ def _matches(self, item: Sequence[str]) -> bool:
     def describe_to(self, description: Description) -> None:
         """Describe the passing case."""
         description.append_text(
-            f"a sequence containing an element which matches {self.pattern}"
+            f'a sequence containing an element which matches r"{self.pattern}"'
         )
 
     def describe_match(self, _: Sequence[str], match_description: Description) -> None:
@@ -43,7 +43,7 @@ def describe_mismatch(
             mismatch_description.append_text("was not a sequence")
             return
         mismatch_description.append_text(
-            f"did not contain an item matching {self.pattern}"
+            f'did not contain an item matching r"{self.pattern}"'
         )
 
 

screenpy/resolutions/ends_with.py

@@ -6,6 +6,7 @@
 from hamcrest.core.matcher import Matcher
 
 from screenpy.pacing import beat
+from screenpy.speech_tools import represent_prop
 
 
 class EndsWith:
@@ -20,12 +21,13 @@ class EndsWith:
 
     def describe(self) -> str:
         """Describe the Resolution's expectation."""
-        return f'Ending with "{self.postfix}".'
+        return f"Ending with {self.postfix_to_log}."
 
-    @beat('... hoping it ends with "{postfix}".')
+    @beat("... hoping it ends with {postfix_to_log}.")
     def resolve(self) -> Matcher[str]:
         """Produce the Matcher to make the assertion."""
         return ends_with(self.postfix)
 
     def __init__(self, postfix: str) -> None:
         self.postfix = postfix
+        self.postfix_to_log = represent_prop(postfix)

screenpy/resolutions/is_equal_to.py

@@ -8,6 +8,7 @@
 from hamcrest.core.matcher import Matcher
 
 from screenpy.pacing import beat
+from screenpy.speech_tools import represent_prop
 
 
 class IsEqualTo:
@@ -22,12 +23,13 @@ class IsEqualTo:
 
     def describe(self) -> str:
         """Describe the Resolution's expectation."""
-        return f"Equal to {self.expected}."
+        return f"Equal to {self.expected_to_log}."
 
-    @beat("... hoping it's equal to {expected}.")
+    @beat("... hoping it's equal to {expected_to_log}.")
     def resolve(self) -> Matcher[Any]:
         """Produce the Matcher to make the assertion."""
         return equal_to(self.expected)
 
     def __init__(self, obj: Any) -> None:
         self.expected = obj
+        self.expected_to_log = represent_prop(obj)

screenpy/resolutions/is_greater_than.py

@@ -8,6 +8,7 @@
 from hamcrest.core.matcher import Matcher
 
 from screenpy.pacing import beat
+from screenpy.speech_tools import represent_prop
 
 
 class IsGreaterThan:
@@ -20,12 +21,13 @@ class IsGreaterThan:
 
     def describe(self) -> str:
         """Describe the Resolution's expectation."""
-        return f"Greater than {self.number}."
+        return f"Greater than {self.number_to_log}."
 
-    @beat("... hoping it's greater than {number}.")
+    @beat("... hoping it's greater than {number_to_log}.")
     def resolve(self) -> Matcher[Any]:
         """Produce the Matcher to make the assertion."""
         return greater_than(self.number)
 
     def __init__(self, number: float) -> None:
         self.number = number
+        self.number_to_log = represent_prop(number)

screenpy/resolutions/is_greater_than_or_equal_to.py

@@ -8,6 +8,7 @@
 from hamcrest.core.matcher import Matcher
 
 from screenpy.pacing import beat
+from screenpy.speech_tools import represent_prop
 
 
 class IsGreaterThanOrEqualTo:
@@ -22,12 +23,13 @@ class IsGreaterThanOrEqualTo:
 
     def describe(self) -> str:
         """Describe the Resolution's expectation."""
-        return f"Greater than or equal to {self.number}."
+        return f"Greater than or equal to {self.number_to_log}."
 
-    @beat("... hoping it's greater than or equal to {number}.")
+    @beat("... hoping it's greater than or equal to {number_to_log}.")
     def resolve(self) -> Matcher[Any]:
         """Produce the Matcher to make the assertion."""
         return greater_than_or_equal_to(self.number)
 
     def __init__(self, number: float) -> None:
         self.number = number
+        self.number_to_log = represent_prop(number)

screenpy/resolutions/is_less_than.py

@@ -6,6 +6,7 @@
 from hamcrest.core.matcher import Matcher
 
 from screenpy.pacing import beat
+from screenpy.speech_tools import represent_prop
 
 
 class IsLessThan:
@@ -20,12 +21,13 @@ class IsLessThan:
 
     def describe(self) -> str:
         """Describe the Resolution's expectation."""
-        return f"Less than {self.number}."
+        return f"Less than {self.number_to_log}."
 
-    @beat("... hoping it's less than {number}.")
+    @beat("... hoping it's less than {number_to_log}.")
     def resolve(self) -> Matcher[float]:
         """Produce the Matcher to make the assertion."""
         return less_than(self.number)
 
     def __init__(self, number: float) -> None:
         self.number = number
+        self.number_to_log = represent_prop(number)

screenpy/resolutions/is_less_than_or_equal_to.py

@@ -6,6 +6,7 @@
 from hamcrest.core.matcher import Matcher
 
 from screenpy.pacing import beat
+from screenpy.speech_tools import represent_prop
 
 
 class IsLessThanOrEqualTo:
@@ -20,12 +21,13 @@ class IsLessThanOrEqualTo:
 
     def describe(self) -> str:
         """Describe the Resolution's expectation."""
-        return f"Less than or equal to {self.number}."
+        return f"Less than or equal to {self.number_to_log}."
 
-    @beat("... hoping it's less than or equal to {number}.")
+    @beat("... hoping it's less than or equal to {number_to_log}.")
     def resolve(self) -> Matcher[float]:
         """Produce the Matcher to make the assertion."""
         return less_than_or_equal_to(self.number)
 
     def __init__(self, number: float) -> None:
         self.number = number
+        self.number_to_log = represent_prop(number)

screenpy/resolutions/reads_exactly.py

@@ -6,6 +6,7 @@
 from hamcrest.core.matcher import Matcher
 
 from screenpy.pacing import beat
+from screenpy.speech_tools import represent_prop
 
 
 class ReadsExactly:
@@ -20,12 +21,13 @@ class ReadsExactly:
 
     def describe(self) -> str:
         """Describe the Resolution's expectation."""
-        return f'"{self.text}", verbatim.'
+        return f"{self.text_to_log}, verbatim."
 
-    @beat('... hoping it\'s "{text}", verbatim.')
+    @beat("... hoping it's {text_to_log}, verbatim.")
     def resolve(self) -> Matcher[object]:
         """Produce the Matcher to make the assertion."""
         return has_string(self.text)
 
     def __init__(self, text: str) -> None:
         self.text = text
+        self.text_to_log = represent_prop(text)

screenpy/resolutions/starts_with.py

@@ -6,6 +6,7 @@
 from hamcrest.core.matcher import Matcher
 
 from screenpy.pacing import beat
+from screenpy.speech_tools import represent_prop
 
 
 class StartsWith:
@@ -20,12 +21,13 @@ class StartsWith:
 
     def describe(self) -> str:
         """Describe the Resolution's expectation."""
-        return f'Starting with "{self.prefix}".'
+        return f"Starting with {self.prefix_to_log}."
 
-    @beat('... hoping it starts with "{prefix}".')
+    @beat("... hoping it starts with {prefix_to_log}.")
     def resolve(self) -> Matcher[str]:
         """Produce the Matcher to make the assertion."""
         return starts_with(self.prefix)
 
     def __init__(self, prefix: str) -> None:
         self.prefix = prefix
+        self.prefix_to_log = represent_prop(prefix)