fixing black formatting now that COM812 is disabled (ScreenPyHQ#159)

Author: bandophahita

screenpy/actions/eventually.py

@@ -52,10 +52,7 @@ class _TimeframeBuilder:
         """Build a timeframe, combining numbers and units."""
 
         def __init__(
-            self,
-            eventually: Eventually,
-            amount: float,
-            attribute: str,
+            self, eventually: Eventually, amount: float, attribute: str
         ) -> None:
             self.eventually = eventually
             self.amount = amount

screenpy/actions/stop.py

@@ -50,9 +50,7 @@ def until_the(cls, question: Answerable, resolution: Resolvable) -> Self:
         return cls(question, resolution)
 
     def __init__(
-        self,
-        question: Answerable | None = None,
-        resolution: Resolvable | None = None,
+        self, question: Answerable | None = None, resolution: Resolvable | None = None
     ) -> None:
         self.question = question
         self.resolution = resolution
@@ -91,7 +89,7 @@ def perform_as(self, the_actor: Actor) -> None:
 
         try:
             the_actor.attempts_to(
-                Silently(Eventually(See.the(self.question, self.resolution))),
+                Silently(Eventually(See.the(self.question, self.resolution)))
             )
         except DeliveryError as caught_exception:
             msg = (

screenpy/configuration.py

@@ -102,14 +102,10 @@ def __call__(self) -> dict[str, Any]:
 
         for field_name, field in self.settings_cls.model_fields.items():
             field_value, field_key, value_is_complex = self.get_field_value(
-                field,
-                field_name,
+                field, field_name
             )
             field_value = self.prepare_field_value(
-                field_name,
-                field,
-                field_value,
-                value_is_complex=value_is_complex,
+                field_name, field, field_value, value_is_complex=value_is_complex
             )
             if field_value is not None:
                 toml_config[field_key] = field_value

screenpy/narration/narrator.py

@@ -203,50 +203,39 @@ def narrate(self, channel: str, **kwargs: Kwargs | None) -> AbstractContextManag
             enclosed_func = self._dummy_entangle(channel_kws["func"])
             channel_kws["func"] = lambda: "overflow"
             self.backed_up_narrations[-1].append(
-                (channel, channel_kws, self.exit_level),
+                (channel, channel_kws, self.exit_level)
             )
         else:
             enclosed_func = self._entangle_func(channel, None, **channel_kws)
 
         return enclosed_func
 
     def announcing_the_act(
-        self,
-        func: Callable,
-        line: str,
-        gravitas: str | None = None,
+        self, func: Callable, line: str, gravitas: str | None = None
     ) -> AbstractContextManager:
         """Narrate the title of the act."""
         if not self.on_air:
             return self._dummy_entangle(func)
         return self.narrate("act", func=func, line=line, gravitas=gravitas)
 
     def setting_the_scene(
-        self,
-        func: Callable,
-        line: str,
-        gravitas: str | None = None,
+        self, func: Callable, line: str, gravitas: str | None = None
     ) -> AbstractContextManager:
         """Narrate the title of the scene."""
         if not self.on_air:
             return self._dummy_entangle(func)
         return self.narrate("scene", func=func, line=line, gravitas=gravitas)
 
     def stating_a_beat(
-        self,
-        func: Callable,
-        line: str,
-        gravitas: str | None = None,
+        self, func: Callable, line: str, gravitas: str | None = None
     ) -> AbstractContextManager:
         """Narrate an emotional beat."""
         if not self.on_air:
             return self._dummy_entangle(func)
         return self.narrate("beat", func=func, line=line, gravitas=gravitas)
 
     def whispering_an_aside(
-        self,
-        line: str,
-        gravitas: str | None = None,
+        self, line: str, gravitas: str | None = None
     ) -> AbstractContextManager:
         """Narrate a conspiratorial aside (as a stage-whisper)."""
         if not self.on_air:

screenpy/narration/stdout_adapter/stdout_adapter.py

@@ -81,7 +81,7 @@ class StdOutAdapter:
             NORMAL: logging.WARNING,
             HEAVY: logging.CRITICAL,
             EXTREME: logging.ERROR,
-        },
+        }
     )
 
     def __init__(self, stdout_manager: StdOutManager | None = None) -> None:
@@ -106,10 +106,7 @@ def func_wrapper(*args: P.args, **kwargs: P.kwargs) -> Callable[P, T]:
         yield func_wrapper
 
     def scene(
-        self,
-        func: Callable,
-        line: str,
-        gravitas: str | None = None,
+        self, func: Callable, line: str, gravitas: str | None = None
     ) -> Generator:
         """Wrap the scene, to log the stylized title."""
 
@@ -133,10 +130,7 @@ def beat(self, func: Callable, line: str, gravitas: str | None = None) -> Genera
             yield func
 
     def aside(
-        self,
-        func: Callable,
-        line: str,
-        gravitas: str | None = None,
+        self, func: Callable, line: str, gravitas: str | None = None
     ) -> Generator:
         """Encapsulate the aside within the manager's log context."""
         if not gravitas:

screenpy/pacing.py

@@ -36,8 +36,7 @@ def function_should_log_none(func: Callable[P, T]) -> bool:
 
 
 def act(
-    title: str,
-    gravitas: str | None = None,
+    title: str, gravitas: str | None = None
 ) -> Callable[[Callable[P, T]], Callable[P, T]]:
     """Decorator to mark an "act".
 
@@ -61,8 +60,7 @@ def decorator(func: Callable[P, T]) -> Callable[P, T]:
 
 
 def scene(
-    title: str,
-    gravitas: str | None = None,
+    title: str, gravitas: str | None = None
 ) -> Callable[[Callable[P, T]], Callable[P, T]]:
     """Decorator to mark a "scene".
 
@@ -86,8 +84,7 @@ def decorator(func: Callable[P, T]) -> Callable[P, T]:
 
 
 def beat(
-    line: str,
-    gravitas: str | None = None,
+    line: str, gravitas: str | None = None
 ) -> Callable[[Callable[P, T]], Callable[P, T]]:
     """Decorator to describe a "beat" (a step in a test).
 

screenpy/protocols.py

@@ -115,21 +115,15 @@ def act(self, func: Callable, line: str, gravitas: str | None = None) -> Generat
         """Handle narrating an Act, which designates a group of tests."""
 
     def scene(
-        self,
-        func: Callable,
-        line: str,
-        gravitas: str | None = None,
+        self, func: Callable, line: str, gravitas: str | None = None
     ) -> Generator:
         """Handle narrating a Scene, which designates a subgroup of tests."""
 
     def beat(self, func: Callable, line: str, gravitas: str | None = None) -> Generator:
         """Handle narrating a Beat, which is a step in a test."""
 
     def aside(
-        self,
-        func: Callable,
-        line: str,
-        gravitas: str | None = None,
+        self, func: Callable, line: str, gravitas: str | None = None
     ) -> Generator:
         """Handle narrating an Aside, which can happen any time."""
 

screenpy/resolutions/custom_matchers/is_in_bounds.py

@@ -56,20 +56,20 @@ def _matches(self, item: float) -> bool:
     def describe_to(self, description: Description) -> None:
         """Describe the passing case."""
         description.append_text(
-            f"the number is within the range of {self.minorant} and {self.majorant}",
+            f"the number is within the range of {self.minorant} and {self.majorant}"
         )
 
     def describe_match(self, item: float, match_description: Description) -> None:
         """Describe the match."""
         match_description.append_text(
-            f"{item} was within the range of {self.minorant} and {self.majorant}",
+            f"{item} was within the range of {self.minorant} and {self.majorant}"
         )
 
     def describe_mismatch(self, item: float, mismatch_description: Description) -> None:
         """Describe the failing case."""
         mismatch_description.append_text(
             f"{item} does not fall within the range of"
-            f" {self.minorant} and {self.majorant}",
+            f" {self.minorant} and {self.majorant}"
         )
 
 
@@ -86,7 +86,7 @@ def is_in_bounds(*bounds: float | str) -> IsInBounds:
             r"[\-, ]+?"  # any number of comma, dash and space
             r"(?P<majorant>-?(\d+\.?\d*)|(\.\d+))"  # majorant (int or float)
             r"(?P<upper>[])]?)"  # ) or ]
-            r"$",  # end of line
+            r"$"  # end of line
         )
         matched = re.match(pattern, bounding_string)
         if matched is None:

screenpy/resolutions/custom_matchers/sequence_containing_pattern.py

@@ -26,24 +26,22 @@ 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 r'{self.pattern}'",
+            f"a sequence containing an element which matches r'{self.pattern}'"
         )
 
     def describe_match(self, _: Sequence[str], match_description: Description) -> None:
         """Describe the match, for use with IsNot."""
         match_description.append_text(f"it contains an item matching r'{self.pattern}'")
 
     def describe_mismatch(
-        self,
-        item: Sequence[str],
-        mismatch_description: Description,
+        self, item: Sequence[str], mismatch_description: Description
     ) -> None:
         """Describe the failing case."""
         if item is None or not hasattr(item, "__iter__"):
             mismatch_description.append_text("was not a sequence")
             return
         mismatch_description.append_text(
-            f"did not contain an item matching r'{self.pattern}'",
+            f"did not contain an item matching r'{self.pattern}'"
         )