classes.c12_glyph

  1from functools import cached_property
  2from loguru import logger
  3import drawBot
  4import colorama
  5from icecream import ic
  6
  7from lib import fonts, helpers, glyphs
  8
  9
 10class KGlyph:
 11    def __init__(self, source: str) -> None:
 12        """Initialize a KGlyph instance."""
 13        self.source: str = source
 14        """The glyph source identifier. Can be character, name, or unicode."""
 15
 16    @cached_property
 17    def name(self) -> str:
 18        """
 19        Returns:
 20            The glyph name, see `lib.glyphs.toName`.
 21
 22        Example:
 23            ccaron
 24        """
 25        return glyphs.toName(self.source)
 26
 27    @cached_property
 28    def char(self) -> str:
 29        """
 30        Returns:
 31            The corresponding character, see `lib.glyphs.toChar`.
 32
 33        Example:
 34            č
 35        """
 36        return glyphs.toChar(self.source)
 37
 38    @cached_property
 39    def charBase(self) -> str:
 40        """
 41        Returns:
 42            The base character of the glyph, see `lib.glyphs.toCharBase`.
 43
 44        Example:
 45            Á.ss01 => Á
 46            S.ss01.cv01 => S
 47        """
 48        return glyphs.toCharBase(self.source)
 49
 50    @cached_property
 51    def unicode(self) -> str:
 52        """
 53        Returns:
 54            The corresponding unicode string, see `lib.glyphs.toUni`.
 55
 56        Example:
 57            uni010D
 58        """
 59        return glyphs.toUni(self.source, "full")
 60
 61    @cached_property
 62    def category(self) -> str:
 63        """Returns the glyph category, see `lib.glyphs.getCategory`."""
 64        return glyphs.getCategory(self.source)
 65
 66    @cached_property
 67    def canLigate(self) -> bool:
 68        """Returns True if source is a multi-char sequence that can form a ligature.
 69
 70        See `lib.glyphs.canLigate`.
 71
 72        Examples:
 73            KGlyph("fi").canLigate  => True
 74            KGlyph("f_i").canLigate => False
 75        """
 76        return glyphs.canLigate(self.source)
 77
 78    @cached_property
 79    def isLigature(self) -> bool:
 80        """Returns True if source represents an actual ligature glyph.
 81
 82        See `lib.glyphs.isLigature`.
 83
 84        Examples:
 85            KGlyph("fi").isLigature    => True
 86            KGlyph("f_i").isLigature   => True
 87            KGlyph("tt").isLigature    => False
 88        """
 89        return glyphs.isLigature(self.source)
 90
 91    def get(self, key: str, defaultValue=None):
 92        """
 93        Retrieve an attribute by key, emulating `dict.get()`.
 94
 95        Args:
 96            key: The attribute name to retrieve.
 97            defaultValue: Value to return if the attribute is not found.
 98
 99        Returns:
100            The attribute value or defaultValue if not found.
101        """
102        return getattr(self, key, defaultValue)
103
104    def getSupported(self, fontPath: str, warn: bool = True) -> str | None:
105        """
106        Find the supported glyph name in the given font.
107
108        Args:
109            fontPath: The font path to check for glyph support.
110
111        Returns:
112            The name of the supported glyph in the font, or None if not found.
113        """
114        glyphsInFont = glyphs.listAvailableGlyphs(fontPath)
115
116        possibleMatches = set(
117            helpers.removeNone(
118                [
119                    *helpers.coerceList(self.name),
120                    self.char,
121                    self.unicode,
122                    glyphs.toSnakeCase(self.source),
123                    glyphs.toPartBase(self.source),
124                ]
125            )
126        )
127        # ! Edge case: For certain ligatures like "t_t", some fonts may use a ".liga" suffix for the supported glyph name.
128        if self.canLigate:
129            possibleMatches.update(
130                [
131                    f"{variant}.liga"
132                    for variant in [self.name, glyphs.toSnakeCase(self.source)]
133                ]
134            )
135
136        for possibleMatch in possibleMatches:
137            if possibleMatch in glyphsInFont:
138                return possibleMatch
139
140        if warn:
141            logger.warning(
142                "{} doesn’t support glyph {}",
143                fonts.getFontName(fontPath),
144                f"{colorama.Back.LIGHTYELLOW_EX}{self.source}{colorama.Style.RESET_ALL}",
145            )
146
147    def __str__(self) -> str:
148        """Returns a human-friendly string representation of the KGlyph, including name, character, unicode, and category."""
149        output = f"{colorama.Back.BLACK}KGlyph{colorama.Style.RESET_ALL}"
150
151        if self.name:
152            # Can be multiple names
153            isMultipleNames = isinstance(self.name, list)
154            names = helpers.coerceList(self.name)
155
156            output += " Name" + ("s" if isMultipleNames else " ")
157            for ni, name in enumerate(names):
158                isNotFirst = ni != 0
159                if isNotFirst:
160                    output += "\n" + " " * 12
161                output += f" {colorama.Back.LIGHTYELLOW_EX}{name.ljust(30)}{colorama.Style.RESET_ALL}"
162
163        if self.char:
164            output += f" Char {colorama.Back.BLUE}{self.char}{colorama.Style.RESET_ALL}"
165            # Justify text
166            charAllotedSpaces = 6
167            if self.name == "zerowidthspace":
168                charAllotedSpaces += 1
169            output += " " * (charAllotedSpaces - len(self.char))
170
171        unicodeToPrint = self.unicode or ""
172        output += (
173            f" Unicode {colorama.Back.CYAN}{unicodeToPrint}{colorama.Style.RESET_ALL}"
174        )
175        output += " " * (9 - len(unicodeToPrint))
176
177        output += f" Category {colorama.Back.LIGHTRED_EX}{self.category}{colorama.Style.RESET_ALL}"
178
179        return output