lib.content

  1import re
  2import drawBot
  3import random
  4from math import ceil
  5from typing import Literal, TypeAlias, Union
  6from itertools import cycle, islice, dropwhile
  7from string import capwords
  8import regex
  9from caseconverter import camelcase, kebabcase, snakecase
 10from loguru import logger
 11from icecream import ic
 12
 13from lib import helpers, layout, fonts, DEFAULT_FONT
 14
 15
 16WordShape: TypeAlias = Literal["descender", "ascender", "caps"]
 17"""Categories to filter words by their shape.
 18
 19See `classes.c32_pool.KPool.getItemByWidth` for usage.
 20"""
 21
 22TextCase: TypeAlias = Literal[
 23    "UPPER",
 24    "lower",
 25    "title",
 26    "title-force",
 27]
 28"""Defines the supported text casing styles for conversion.
 29
 30- `UPPER`: Converts all letters to uppercase: `hi ibm` → `HI IBM`
 31- `lower`: Converts all letters to lowercase: `HI IBM` → `hi ibm`
 32- `title`: Capitalizes each word, but preserves acronyms in uppercase: `hi ibm USA` → `Hi Ibm USA`
 33- `title-force`: Capitalizes each word and forces acronym recasing: `hi ibm USA` → `Hi Ibm Usa`
 34"""
 35
 36CharacterToken: TypeAlias = Literal["word", "nonword"]
 37"""Type alias for character token types.
 38
 39See `filterByTokens` for usage.
 40"""
 41
 42
 43# ? Common words that should be lowercased in title case (unless at the start/end)
 44commonWords: list[str] = [
 45    # articles
 46    "a",
 47    "an",
 48    "the",
 49    # prepositions <= 3 letters
 50    "at",
 51    "of",
 52    "on",
 53    "up",
 54    "in",
 55    "by",
 56    "to",
 57    # conjunctions
 58    "and",
 59    "as",
 60    "for",
 61    "but",
 62    "nor",
 63    "or",
 64    "so",
 65    "yet",
 66]
 67"""List of common words to be lowercased in title case (unless at start/end)."""
 68
 69
 70def toPascalCase(input: str, space: bool = True) -> str:
 71    """Convert string to PascalCase, optionally inserting spaces between words and numbers.
 72
 73    Args:
 74        input: The input string.
 75        space: If True, insert spaces between (default: True).
 76
 77    Example:
 78        `One123Four` => `One 123 Four`
 79    """
 80    # ? Not using caseconverter.pascalcase() because it alters allcaps words
 81    # Replace separators with spaces
 82    input = re.sub(r"[-_]+", " ", input)
 83    separator = " " if space else ""
 84    # A Aa, a A, A 0
 85    expressions = ["([A-Z0-9])([A-Z][a-z])", "([a-z])([A-Z])", "([A-Za-z])([0-9])"]
 86    for exp in expressions:
 87        input = re.sub(rf"{exp}", rf"\1{separator}\2", input)
 88    return input[:1].upper() + input[1:]
 89
 90
 91def toCamelCase(input: str):
 92    """Convert string to camelCase.
 93
 94    Example:
 95        `Hello World` => `helloWorld`
 96    """
 97    return camelcase(input)
 98
 99
100def toKebabCase(input: str) -> str:
101    """Convert string to kebab-case.
102
103    Example:
104        `Hello World` => `hello-world`
105    """
106    return kebabcase(input)
107
108
109def toSnakeCase(input: str) -> str:
110    """Convert string to snake_case.
111
112    Example:
113        `Hello World` => `hello_world`
114    """
115    return snakecase(input)
116
117
118def toTitleCase(input: str, retainUpper: bool = True) -> str:
119    """
120    Convert string to title case, handling special cases and acronyms.
121
122    Args:
123        input: The input string.
124        retainUpper: If True, retain uppercase acronyms: `True` USA, `False` Usa
125
126    Returns:
127        Title-cased string.
128
129    Example:
130        `sON Of The USA` => `Son of the USA`
131    """
132    specialChars: list[str] = ["-", "/"]
133
134    def _capitalizeAfterPunctuation(
135        word: str,
136    ) -> str:
137        """Capitalize first lowercase letter even when preceded by punctuation."""
138        hasUpperRun = bool(regex.search(r"\p{Lu}{2,}", word))
139        if not retainUpper and hasUpperRun:
140            word = capwords(word)
141
142        return regex.sub(
143            r"^([^\p{L}\p{N}]*)(\p{Ll})",
144            lambda match: f"{match.group(1)}{match.group(2).upper()}",
145            word,
146            count=1,
147        )
148
149    def _hasSpecialChars(word: str) -> bool:
150        """Returns True if word contains special characters."""
151        return any(char in word for char in specialChars)
152
153    def _handleSpecialChars(word: str) -> str:
154        """Apply title case to each part of a word split by special characters."""
155        for char in specialChars:
156            if char in word:
157                # ? Split by special char and apply title case to each part
158                parts = word.split(char)
159                return char.join([_capitalizeAfterPunctuation(part) for part in parts])
160
161    def _processWord(word: str, i: int) -> str:
162        """Process a single word for title casing."""
163        # ? Always lowercase common words in continuous text
164        isOnEitherSide = i == 0 or i == len(words) - 1
165        isCommon = word.casefold() in commonWords
166        if isCommon and not isOnEitherSide:
167            return word.lower()
168
169        # ? Handle special characters
170        if _hasSpecialChars(word):
171            return _handleSpecialChars(word)
172
173        # Uppercase and punctuation 2+ times
174        isCaps = regex.match(r"[\p{Lu}|\p{P}]{2,}", word)
175
176        # capwords() better .title() => retains lowercase ’s
177        return word if isCaps and retainUpper else _capitalizeAfterPunctuation(word)
178
179    words = input.split(" ")
180    words = [_processWord(word, i) for i, word in enumerate(words)]
181    return " ".join(words)
182
183
184def changeCase(
185    input: list[str] | str,
186    case: TextCase = "title",
187) -> list[str] | str:
188    """
189    Change the case of a string or list of strings.
190
191    Args:
192        input: String or list of strings to change case.
193        case: Desired case ("upper", "lower", "title", "title-force").
194
195    Returns:
196        String or list of strings with changed case.
197
198    Example:
199        `the USA`
200        - `upper` => `THE USA`
201        - `lower` => `the usa`
202        - `title`       => `The USA`
203        - `title-force` => `The Usa`
204    """
205
206    def _change(item: str):
207        if case.casefold() == "upper":
208            return item.upper()
209        elif case.casefold() == "lower":
210            return item.lower()
211        elif case.casefold() == "title":
212            return toTitleCase(item)
213        elif case.casefold() == "title-force":
214            return toTitleCase(item, False)
215        else:
216            logger.warning("Unable to change case: {}", case)
217
218    if not case:
219        return input  # Pass through unchanged
220
221    if isinstance(input, list):
222        return [_change(item) for item in input]
223    else:
224        return _change(input)
225
226
227def dedupeCase(input: list[str], case: TextCase = "title") -> list[str]:
228    """
229    Remove duplicates from a list of strings after changing their case.
230
231    Args:
232        input: List of strings to dedupe.
233        case: Case to apply before deduplication.
234    """
235    return list(set(changeCase(input, case)))
236
237
238def dedupeWords(input: str) -> str:
239    """Collapse adjacent duplicate words in a string (case-insensitive)."""
240    duplicateWordPattern = (
241        r"\b([A-Za-zÀ-ÖØ-öø-ÿ0-9]+(?:[-'][A-Za-zÀ-ÖØ-öø-ÿ0-9]+)?)\s+\1\b"
242    )
243
244    output = input
245    previous = None
246    while output != previous:
247        previous = output
248        output = re.sub(duplicateWordPattern, r"\1", output, flags=re.IGNORECASE)
249
250    return output
251
252
253def isTitleCase(input: str) -> bool:
254    """Returns True if all words in the string are title case."""
255    return all([regex.match(r"^[\p{Lu}][\p{Ll}]+$", part) for part in input.split(" ")])
256
257
258def omitMissing(
259    input: str | list[str],
260    font: str = None,
261    mode: Literal["glyphs", "words", "lines"] = "words",
262    debug=False,
263):
264    """
265    Omit missing characters from text or list of text blocks.
266
267    Args:
268        input: A single string or a list of strings to check for missing glyphs.
269        font: Font to use for checking glyphs (optional).
270        mode: Determines the omission granularity:
271            - `glyphs`: Omit only the missing characters, preserving the rest of the text.
272            - `words`: Omit entire words that contain missing glyphs.
273            - `lines`: Omit entire lines that contain missing glyphs.
274        debug: If True, log omitted units.
275
276    Returns:
277        Filtered text or list of text blocks with missing data omitted, depending on mode.
278    """
279    if font:
280        drawBot.font(font)
281    elif drawBot.fontFilePath() == DEFAULT_FONT:
282        logger.warning("Default font used to check character set.")
283
284    isInputString = isinstance(input, str)
285    match mode:
286        case "glyphs":
287            glue = ""
288        case "words":
289            glue = " "
290        case "lines":
291            glue = "\n"
292    blocks = [input] if isInputString else input
293
294    output = []
295    for block in blocks:
296        units = list(block) if mode == "glyphs" else block.split(glue)
297        filtered = [unit for unit in units if drawBot.fontContainsCharacters(unit)]
298
299        if debug:
300            # Log omitted fontName if available
301            _logMessage = lambda unit: (
302                ("[Omitted] {} for {}", unit, fonts.getFontName(font))
303                if font
304                else ("[Omitted] {}", unit)
305            )
306            [
307                logger.trace(*_logMessage(unit))
308                for unit in units
309                if not drawBot.fontContainsCharacters(unit)
310            ]
311
312        # Do not add empty list
313        if filtered:
314            output.append(glue.join(filtered))
315
316    return glue.join(output) if isInputString else output
317
318
319def splitStringToSentences(input: str) -> list[str]:
320    """
321    Split running text into a list of sentences.
322
323    Args:
324        input: The input text.
325
326    Example:
327        `I am a sentence. I am another one.` => `["I am a sentence.", "I am another one."]`
328    """
329    replacements = [
330        # Newlines with spaces
331        (r"\n", " "),
332        # Multiple spaces to single space
333        (r"\s{2,}", " "),
334    ]
335    for [before, after] in replacements:
336        input = re.sub(rf"{before}", after, input)
337
338    # Skip abbreviations: (F. Elastica), Ficus var. elastica
339    sentenceExp = r"(?<!\w\.\w.)(?<![A-Z][a-z]\.)(?<![A-Z]\.)(?<=\.|\?)\s(?![a-z])"
340    return re.split(sentenceExp, input)
341
342
343def rotateList(input: list) -> list:
344    """
345    Rotate a list to produce all cyclic permutations.
346
347    Args:
348        input: The input list.
349
350    Example:
351        `[A, B, C]` => `[[A, B, C], [B, C, A], [C, A, B]]`
352    """
353    output = []
354
355    for item in input:
356        cycled = cycle(input)
357        skipped = dropwhile(lambda x: x != item, cycled)
358        sliced = islice(skipped, None, len(input))
359
360        output.append(list(sliced))
361
362    return output
363
364
365def chopSequence(input: str | list[str], limit: int = None, glue=" ", split=" "):
366    """
367    Split input into meaningful parts, optionally limiting the number of words: `A B C` => `A, AB, ABC`.
368
369    Args:
370        input: String or list of strings to chop.
371        limit: Limit to `n` words.
372        glue: String to join parts.
373        split: String to split input.
374
375    Example:
376    - input: single sentence
377        - `"I was late."` => `["I", "I was", "I was late."]`
378    - input: list of sentences
379        - `["For me.", "Right?"]` => `["For me.", "For me. Right?"]`
380    - limit: 2
381        - `["I", "I was"]`
382    """
383    if split and isinstance(input, str):
384        input = input.split(split)
385
386    inputLen = len(input)
387    # Limit size if provided
388    stop = min(limit, inputLen) if limit else inputLen
389
390    return [glue.join(input[:i]) for i in range(1, stop + 1)]
391
392
393def chopList(
394    input: list[str],
395    clamp: int = None,
396    mode: Literal["separate", "connected"] = "separate",
397    shuffle=False,
398) -> list[str]:
399    """
400    Chop a list of sentences into smaller parts, optionally connecting or shuffling them.
401
402    Args:
403        input: List of sentences.
404        clamp: Limit to n words per iteration.
405        mode: "separate" to chop individually, "connected" to connect chopped sentences.
406        shuffle: If True, shuffle input before chopping.
407
408    Example:
409        `["Hello there.", "Hi you."]` =>
410        - (separate) `["Hello", "Hello there.", "Hi", "Hi you."]`
411        - (connected) `["Hello", "Hello there.", "Hello there. Hi", ...]`
412    """
413    if shuffle:
414        random.shuffle(input)
415
416    if mode == "connected":
417        input = [" ".join(item) for item in rotateList(input)]
418
419    return helpers.flatten([chopSequence(item, clamp) for item in input])
420
421
422def permutate(input: list, clamp=20, shuffle=True) -> list:
423    """
424    Permutate and chop a list of sentences into connected sequences.
425
426    Args:
427        input: List of sentences.
428        clamp: Limit to `n` words per sequence.
429        shuffle: If True, shuffle input before permutation.
430
431    Example:
432        - `["Hi Tim", "Foo bar"]` => list of
433        - `["Hi", "Hi Tim", "Hi Tim Foo", ...], ["Foo", "Foo bar", "Foo bar Hi", ...]`
434    """
435    return chopList(input, clamp, "connected", shuffle)
436
437
438def fillTextOver(container: tuple, content: list, shuffle: bool = True) -> str:
439    """
440    Returns a string that fills the container up to overflow.
441
442    - Font properties need to be already set
443
444    Args:
445        container: Tuple specifying container dimensions.
446        content: List of possible sentences/items.
447        shuffle: If True, shuffle content before filling.
448    """
449    containerW, containerH = layout.toDimensions(container)
450
451    if shuffle:
452        content = helpers.shuffleAtRandomSegment(content)
453
454    strings = []
455
456    for string in content:
457        strings.append(string)
458        stream = " ".join(strings)
459        _, textH = drawBot.textSize(stream, width=containerW)
460        if textH >= containerH:
461            break
462
463    return stream
464
465
466def getStringForWidth(pool: list[str], width: int, threshold: float = 0.995) -> str:
467    """
468    Get a string from the pool that fits within the specified width.
469
470    - Font properties need to be set already
471
472    Args:
473        pool: List of candidate strings.
474        width: Target width.
475        threshold: Minimum width threshold.
476    """
477
478    def _isWidthAppropriate(candidateWidth: int):
479        return minWidth <= candidateWidth <= maxWidth
480
481    minWidth, maxWidth = width * threshold, width
482
483    candidateWidths = []
484    match = None
485
486    for candidate in pool:
487        candidateWidth, _ = drawBot.textSize(candidate)
488        candidateWidths.append(candidateWidth)
489
490        if _isWidthAppropriate(candidateWidth):
491            match = candidate
492            break
493
494    if match:
495        return match
496    else:
497        closestWidth = helpers.findClosestValue(
498            candidateWidths, width, discardLarger=True
499        )
500        i = (
501            candidateWidths.index(closestWidth)
502            if closestWidth in candidateWidths
503            else 0
504        )
505        return pool[i]
506
507
508def _unpackTextBoundsSegment(
509    segment,
510) -> tuple[tuple[float, float, float, float] | None, str]:
511    """Normalize DrawBot text-bounds items across tuple and object variants."""
512
513    def _coerceText(value) -> str:
514        """Convert DrawBot substring payloads to plain text."""
515        if value is None:
516            return ""
517
518        if isinstance(value, str):
519            return value
520
521        rawString = getattr(value, "string", None)
522        if isinstance(rawString, str):
523            return rawString
524
525        try:
526            return str(value)
527        except Exception as e:
528            logger.warning(
529                "Unable to coerce text from segment: {}. Error: {}", value, e
530            )
531            return ""
532
533    if hasattr(segment, "bounds"):
534        text = _coerceText(getattr(segment, "formattedSubString", ""))
535        return segment.bounds, text
536
537    if isinstance(segment, tuple) and len(segment) >= 1:
538        bounds = segment[0]
539        text = ""
540
541        if len(segment) >= 3:
542            text = _coerceText(segment[2])
543        elif len(segment) >= 2:
544            text = _coerceText(segment[1])
545
546        return bounds, text
547
548    return None, ""
549
550
551def _getWrappedLineMetrics(
552    content: Union[str, drawBot.FormattedString], coords: tuple
553) -> list[tuple[float, str]]:
554    """Return wrapped line widths and their concatenated text."""
555
556    textBounds = drawBot.textBoxCharacterBounds(content, coords)
557    linesByY = dict()
558
559    for segment in textBounds:
560        bounds, text = _unpackTextBoundsSegment(segment)
561
562        if not bounds:
563            continue
564
565        _, y, w, _ = bounds
566        key = round(y, 4)
567
568        if not linesByY.get(key):
569            linesByY[key] = dict(width=0.0, parts=[])
570
571        linesByY[key]["width"] += w
572        if text:
573            linesByY[key]["parts"].append(str(text))
574
575    return [
576        (line["width"], "".join(line["parts"]).strip())
577        for line in linesByY.values()
578        if line["width"] > 0
579    ]
580
581
582def _countWords(input: str) -> int:
583    """Count words in a line, including Unicode letters and numbers."""
584
585    return len(
586        regex.findall(
587            r"\p{Letter}[\p{Letter}\p{Mark}\p{Number}'’.-]*|\p{Number}+", input
588        )
589    )
590
591
592def getStringForDimensions(
593    pool: list[str],
594    dimensions: tuple[float, float],
595    threshold: float = 0.85,
596    optimalLastLineRatio: float = 1,
597) -> str:
598    """
599    Get a string from the pool that fits within the specified width and height.
600
601    - Font properties need to be set already
602
603    Args:
604        pool: List of candidate strings.
605        dimensions: Tuple specifying target width and height.
606        threshold: Minimum fill ratio required for every wrapped body line
607            (all lines except the last). Does not affect height scoring.
608        optimalLastLineRatio: Preferred fill ratio for the final wrapped line.
609            `1` prefers the last line to be as full as possible; `0.5` treats
610            half-line endings as ideal.
611    """
612
613    width, height = dimensions
614    minBodyLineWidth, maxWidth = width * threshold, width
615    maxHeight = height
616    optimalLastLineRatio = min(max(optimalLastLineRatio, 0), 1)
617
618    def _measure(candidate: str) -> tuple[float, float]:
619        textW, textH = drawBot.textSize(candidate, width=width)
620
621        # Mirror fitBinary: account for NSFont leading expansion in multiline text.
622        NSFontLeading = drawBot.fontLeading()
623        if NSFontLeading:
624            lineHeight = drawBot.fontLineHeight()
625            if lineHeight:
626                lineCount = ceil(textH / lineHeight)
627                leadingCount = max(0, lineCount - 1)
628                textH += leadingCount * ceil(NSFontLeading)
629
630        return textW, textH
631
632    if not pool:
633        return ""
634
635    measured: list[tuple[str, float, float]] = []
636    for candidate in pool:
637        candidateW, candidateH = _measure(candidate)
638        measured.append((candidate, candidateW, candidateH))
639
640    bestFit: str | None = None
641    bestFitScore: tuple[float, ...] | None = None
642    for candidate, candidateW, candidateH in measured:
643        if candidateW <= maxWidth and candidateH <= maxHeight:
644            widthFill = candidateW / maxWidth if maxWidth else 0
645            heightFill = candidateH / maxHeight if maxHeight else 0
646            fillScore = (heightFill + widthFill) / 2
647
648            bodyLineFillSum = 0.0
649            bodyLineQuality = 0.0
650            lastLineQuality = 0.0
651            lastLineFill = 0.0
652            hasOrphanLastLine = 0
653
654            try:
655                lineMetrics = _getWrappedLineMetrics(candidate, (0, 0, width, height))
656            except Exception:
657                lineMetrics = []
658
659            if lineMetrics:
660                bodyLineMetrics = lineMetrics[:-1]
661
662                if bodyLineMetrics:
663                    if any(
664                        lineWidth < minBodyLineWidth for lineWidth, _ in bodyLineMetrics
665                    ):
666                        continue
667
668                    bodyLineFills = [
669                        (lineWidth / maxWidth if maxWidth else 0)
670                        for lineWidth, _ in bodyLineMetrics
671                    ]
672                    bodyLineFillSum = sum(bodyLineFills)
673                    bodyLineQuality = bodyLineFillSum / len(bodyLineFills)
674                else:
675                    bodyLineQuality = widthFill
676
677                lastLineWidth, lastLineText = lineMetrics[-1]
678                lastLineFill = lastLineWidth / maxWidth if maxWidth else 0
679                lastLineQuality = max(0.0, 1 - abs(lastLineFill - optimalLastLineRatio))
680
681                if len(lineMetrics) > 1 and _countWords(lastLineText) == 1:
682                    hasOrphanLastLine = 1
683            else:
684                bodyLineQuality = widthFill
685
686            orphanPenalty = hasOrphanLastLine * 0.35
687            overallScore = (
688                (bodyLineQuality * 0.45)
689                + (heightFill * 0.3)
690                + (lastLineQuality * 0.25)
691                - orphanPenalty
692            )
693            score = (
694                1 - hasOrphanLastLine,
695                bodyLineFillSum,
696                overallScore,
697                heightFill,
698                bodyLineQuality,
699                fillScore,
700                lastLineQuality,
701                lastLineFill,
702                widthFill,
703            )
704
705            if bestFitScore is None or score > bestFitScore:
706                bestFit = candidate
707                bestFitScore = score
708
709    if bestFit is None:
710        raise ValueError(
711            "No candidates in pool can fit within the specified dimensions."
712        )
713
714    return bestFit
715
716
717def filterByShape(items: list[str], shape: WordShape | list[WordShape]) -> list[str]:
718    """
719    Filter words by descender, ascender, or caps shape.
720
721    Args:
722        items: List of words.
723        shape: Shape(s) to filter by.
724
725    Returns:
726        List of words matching the shape criteria.
727
728    Example:
729        - `["hi", "hey"], "descender"` => `["hi"]`
730    """
731
732    def _isNotShaped(pattern: str, item: str):
733        return not bool(re.search(pattern, item))
734
735    def _checkShape(shape):
736        wordShape = wordShapes.get(shape)
737        return filter(lambda item: _isNotShaped(wordShape, item), items)
738
739    wordShapes = dict(caps="[A-Z0-9]", ascender="[bdfihklt]", descender="[Qgjqpy/,]")
740    shapeSubsets = [_checkShape(shape) for shape in helpers.coerceList(shape)]
741    return helpers.intersect(shapeSubsets, retainOrder=False)
742
743
744def filterByTokens(
745    items: list[str], tokens: list[CharacterToken] = ["word", "nonword"]
746) -> list[str]:
747    """
748    Filter items by Unicode character token.
749
750    Args:
751        items: List of strings to filter.
752        tokens: List of token types to filter by.
753
754    Returns:
755        List of items matching the token criteria.
756
757    Example:
758        - `word`, `nonword` => `["A4", "R&B"]`
759    """
760
761    possiblePatterns = dict(
762        word=r"\p{Letter}", nonword=r"\p{Symbol}|\p{Number}|\p{Punctuation}"
763    )
764    patterns = [possiblePatterns.get(m) for m in tokens]
765
766    def _filterSingleToken(items: list[str], pattern: str):
767        return [item for item in items if bool(regex.search(pattern, item))]
768
769    individual = [_filterSingleToken(items, p) for p in patterns]
770
771    return helpers.intersect(individual)
772
773
774def isRagPretty(
775    content: Union[str, drawBot.FormattedString], coords: tuple
776) -> tuple[bool, bool]:
777    """
778    Evaluate if a paragraph is nicely typeset.
779
780    Args:
781        content: Text content or `FormattedString`.
782        coords: Tuple specifying text box coordinates.
783
784    Returns:
785        Tuple of booleans (isGreat, isOkay).
786        - `isGreat`: All quite long, some very long
787        - `isOkay`: All quite long
788    """
789
790    try:
791        _, _, width, _ = coords
792        lineMetrics = _getWrappedLineMetrics(content, coords)
793
794        if len(lineMetrics) < 2:
795            return False, False
796
797        bodyWidths = [lineWidth for lineWidth, _ in lineMetrics[:-1]]
798        lastWidth = lineMetrics[-1][0]
799        # All lines are quite long
800        areAllGood = all([w >= width * 0.9 for w in bodyWidths])
801        # A portion of lines are very long
802        areSomeGreat = (
803            len([True for w in bodyWidths if w >= width * 0.95]) >= len(bodyWidths) / 3
804        )
805        # Last line is not longest and not an widow
806        isLastGood = max(bodyWidths) >= lastWidth >= width * 2 / 3
807
808        isOkay = areAllGood and isLastGood
809        # isGreat, isOkay
810        return (isOkay and areSomeGreat), isOkay
811    except Exception as e:
812        logger.warning("Failed isRagPretty: {}", e)
813        return False, False