Code coverage

.cruft.json

@@ -1,6 +1,6 @@
 {
   "template": "https://github.com/ScreenPyHQ/cookiecutter_screenpy/",
-  "commit": "2b69298215c08160678dd749884c426a55828dce",
+  "commit": "4ad86820b5729801d7c765e04cfda2e953671164",
   "checkout": null,
   "context": {
     "cookiecutter": {

.gitignore

@@ -147,3 +147,6 @@ dmypy.json
 
 # ruff linter
 .ruff_cache/
+
+#pycharm project files
+.idea/

.pre-commit-config.yaml

@@ -2,17 +2,17 @@ files: '(screenpy|tests)/.*'
 fail_fast: false
 repos:
   - repo: https://github.com/psf/black
-    rev: 24.1.1
+    rev: 24.4.2
     hooks:
       - id: black
         language_version: python3.12
   - repo: https://github.com/astral-sh/ruff-pre-commit
     # Ruff version.
-    rev: v0.2.0
+    rev: v0.5.5
     hooks:
       - id: ruff
   - repo: https://github.com/pre-commit/mirrors-mypy
-    rev: v1.8.0
+    rev: v1.11.1
     hooks:
       - id: mypy
         language_version: python3.12

pyproject.toml

@@ -38,6 +38,7 @@ extend-exclude = '''
 [tool.ruff]
 target-version = "py38"  # minimum supported version
 line-length = 88  # same as Black.
+output-format = "concise"
 extend-exclude = [
     "docs",
 ]
@@ -234,3 +235,16 @@ playwright = ["screenpy-playwright"]
 pyotp = ["screenpy-pyotp"]
 requests = ["screenpy-requests"]
 selenium = ["screenpy-selenium"]
+
+[tool.coverage.run]
+source = ["screenpy"]
+omit = [
+    "/tests/*",
+]
+
+
+[tool.coverage.report]
+exclude_also = [
+    "if TYPE_CHECKING:",
+    "pass",
+]

screenpy/configuration.py

@@ -17,14 +17,14 @@
 
     from pydantic.fields import FieldInfo
 
-if sys.version_info >= (3, 11):
+if sys.version_info >= (3, 11):  # pragma: no cover
     try:
         import tomllib
     except ImportError:
         if not TYPE_CHECKING:
             # Help users on older alphas
             import tomli as tomllib
-else:
+else:  # pragma: no cover
     import tomli as tomllib
 
 
@@ -142,7 +142,7 @@ class ScreenPySettings(BaseSettings):
     """
 
     @classmethod
-    def settings_customise_sources(  # noqa: PLR0913
+    def settings_customise_sources(  # noqa: PLR0913, RUF100
         cls,
         settings_cls: type[BaseSettings],
         init_settings: PydanticBaseSettingsSource,

screenpy/resolutions/contains_item_matching.py

@@ -22,9 +22,9 @@ class ContainsItemMatching:
 
     def describe(self) -> str:
         """Describe the Resolution's expectation."""
-        return f'A sequence with an item matching the pattern r"{self.pattern}".'
+        return f"A sequence with an item matching the pattern r'{self.pattern}'."
 
-    @beat('... hoping it contains an item matching the pattern r"{pattern}".')
+    @beat("... hoping it contains an item matching the pattern r'{pattern}'.")
     def resolve(self) -> Matcher[Sequence[str]]:
         """Produce the Matcher to make the assertion."""
         return has_item_matching(self.pattern)

screenpy/resolutions/custom_matchers/is_in_bounds.py

@@ -22,8 +22,16 @@
     InequalityFunc = Callable[[float, float], bool]
 
 
+class DegenerateIntervalError(ValueError):
+    """ValueError specifically for degenerate intervals."""
+
+
 class IsInBounds(BaseMatcher[float]):
-    """Matches a number which is in the given range."""
+    """Matches a number which is in the given range.
+
+    Only supports proper intervals.
+    https://en.wikipedia.org/wiki/Interval_%28mathematics%29#Notations_for_intervals
+    """
 
     def __init__(
         self,
@@ -32,6 +40,9 @@ def __init__(
         upper_comparator: InequalityFunc,
         majorant: float,
     ) -> None:
+        if minorant >= majorant:
+            msg = f"minorant ({minorant}) must be less than majorant ({majorant})."
+            raise DegenerateIntervalError(msg)
         self.minorant = minorant
         self.lower_comparator = lower_comparator
         self.upper_comparator = upper_comparator
@@ -62,16 +73,20 @@ def describe_mismatch(self, item: float, mismatch_description: Description) -> N
         )
 
 
-def is_in_bounds(*bounds: int | (float | str)) -> IsInBounds:
+def is_in_bounds(*bounds: int | float | str) -> IsInBounds:
     """Matches a number that falls within the bounds."""
     lower_comparator = operator.le
     upper_comparator = operator.le
     if len(bounds) == 1:
         bounding_string = str(bounds[0])
-        pattern = (
-            r"^(?P<lower>[\[\(]?)"
-            r"(?P<minorant>\d+).*?(?P<majorant>\d+)"
-            r"(?P<upper>[\]\)]?)$"
+        pattern = re.compile(
+            r"^"  # start of line
+            r"(?P<lower>[\[(]?)"  # [ or (
+            r"(?P<minorant>-?(\d+\.?\d*)|(\.\d+))"  # minorant (int or float)
+            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
         )
         matched = re.match(pattern, bounding_string)
         if matched is None:

screenpy/resolutions/custom_matchers/sequence_containing_pattern.py

@@ -26,12 +26,12 @@ 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 "{self.pattern}"')
+        match_description.append_text(f"it contains an item matching r'{self.pattern}'")
 
     def describe_mismatch(
         self, item: Sequence[str], mismatch_description: Description
@@ -41,7 +41,7 @@ def describe_mismatch(
             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}'"
         )
 
 

screenpy/resolutions/has_length.py

@@ -6,6 +6,7 @@
 from hamcrest.core.matcher import Matcher
 
 from screenpy.pacing import beat
+from screenpy.speech_tools import represent_prop
 
 
 class HasLength:
@@ -18,16 +19,21 @@ class HasLength:
         )
     """
 
+    @property
+    def length_to_log(self) -> str:
+        """Represent the length in a log-friendly way."""
+        return represent_prop(self.length)
+
     @property
     def item_plural(self) -> str:
         """Decide if we need "item" or "items" in the beat message."""
         return "items" if self.length != 1 else "item"
 
     def describe(self) -> str:
         """Describe the Resolution's expectation."""
-        return f"{self.length} {self.item_plural} long."
+        return f"{self.length_to_log} {self.item_plural} long."
 
-    @beat("... hoping it's a collection with {length} {item_plural} in it.")
+    @beat("... hoping it's a collection with {length_to_log} {item_plural} in it.")
     def resolve(self) -> Matcher[Sized]:
         """Produce the Matcher to make the assertion."""
         return has_length(self.length)

screenpy/resolutions/is_close_to.py

@@ -4,6 +4,7 @@
 from hamcrest.core.matcher import Matcher
 
 from screenpy.pacing import beat
+from screenpy.speech_tools import represent_prop
 
 
 class IsCloseTo:
@@ -16,11 +17,21 @@ class IsCloseTo:
         )
     """
 
+    @property
+    def delta_to_log(self) -> str:
+        """Represent the delta in a log-friendly way."""
+        return represent_prop(self.delta)
+
+    @property
+    def num_to_log(self) -> str:
+        """Represent the num in a log-friendly way."""
+        return represent_prop(self.num)
+
     def describe(self) -> str:
         """Describe the Resolution's expectation."""
-        return f"At most {self.delta} away from {self.num}."
+        return f"At most {self.delta_to_log} away from {self.num_to_log}."
 
-    @beat("... hoping it's at most {delta} away from {num}.")
+    @beat("... hoping it's at most {delta_to_log} away from {num_to_log}.")
     def resolve(self) -> Matcher[float]:
         """Produce the Matcher to make the assertion."""
         return close_to(self.num, self.delta)

screenpy/resolutions/matches.py

@@ -9,7 +9,7 @@
 
 from screenpy.pacing import beat
 
-if TYPE_CHECKING:  # pragma: no cover
+if TYPE_CHECKING:
     from hamcrest.core.matcher import Matcher