mirror of
https://github.com/pacnpal/thrillwiki_django_no_react.git
synced 2025-12-20 07:31:07 -05:00
1339 lines
56 KiB
Python
1339 lines
56 KiB
Python
#
|
|
# The Python Imaging Library.
|
|
# $Id$
|
|
#
|
|
# PIL raster font management
|
|
#
|
|
# History:
|
|
# 1996-08-07 fl created (experimental)
|
|
# 1997-08-25 fl minor adjustments to handle fonts from pilfont 0.3
|
|
# 1999-02-06 fl rewrote most font management stuff in C
|
|
# 1999-03-17 fl take pth files into account in load_path (from Richard Jones)
|
|
# 2001-02-17 fl added freetype support
|
|
# 2001-05-09 fl added TransposedFont wrapper class
|
|
# 2002-03-04 fl make sure we have a "L" or "1" font
|
|
# 2002-12-04 fl skip non-directory entries in the system path
|
|
# 2003-04-29 fl add embedded default font
|
|
# 2003-09-27 fl added support for truetype charmap encodings
|
|
#
|
|
# Todo:
|
|
# Adapt to PILFONT2 format (16-bit fonts, compressed, single file)
|
|
#
|
|
# Copyright (c) 1997-2003 by Secret Labs AB
|
|
# Copyright (c) 1996-2003 by Fredrik Lundh
|
|
#
|
|
# See the README file for information on usage and redistribution.
|
|
#
|
|
|
|
from __future__ import annotations
|
|
|
|
import base64
|
|
import os
|
|
import sys
|
|
import warnings
|
|
from enum import IntEnum
|
|
from io import BytesIO
|
|
from types import ModuleType
|
|
from typing import IO, TYPE_CHECKING, Any, BinaryIO, TypedDict, cast
|
|
|
|
from . import Image, features
|
|
from ._typing import StrOrBytesPath
|
|
from ._util import DeferredError, is_path
|
|
|
|
if TYPE_CHECKING:
|
|
from . import ImageFile
|
|
from ._imaging import ImagingFont
|
|
from ._imagingft import Font
|
|
|
|
|
|
class Axis(TypedDict):
|
|
minimum: int | None
|
|
default: int | None
|
|
maximum: int | None
|
|
name: bytes | None
|
|
|
|
|
|
class Layout(IntEnum):
|
|
BASIC = 0
|
|
RAQM = 1
|
|
|
|
|
|
MAX_STRING_LENGTH = 1_000_000
|
|
|
|
|
|
core: ModuleType | DeferredError
|
|
try:
|
|
from . import _imagingft as core
|
|
except ImportError as ex:
|
|
core = DeferredError.new(ex)
|
|
|
|
|
|
def _string_length_check(text: str | bytes | bytearray) -> None:
|
|
if MAX_STRING_LENGTH is not None and len(text) > MAX_STRING_LENGTH:
|
|
msg = "too many characters in string"
|
|
raise ValueError(msg)
|
|
|
|
|
|
# FIXME: add support for pilfont2 format (see FontFile.py)
|
|
|
|
# --------------------------------------------------------------------
|
|
# Font metrics format:
|
|
# "PILfont" LF
|
|
# fontdescriptor LF
|
|
# (optional) key=value... LF
|
|
# "DATA" LF
|
|
# binary data: 256*10*2 bytes (dx, dy, dstbox, srcbox)
|
|
#
|
|
# To place a character, cut out srcbox and paste at dstbox,
|
|
# relative to the character position. Then move the character
|
|
# position according to dx, dy.
|
|
# --------------------------------------------------------------------
|
|
|
|
|
|
class ImageFont:
|
|
"""PIL font wrapper"""
|
|
|
|
font: ImagingFont
|
|
|
|
def _load_pilfont(self, filename: str) -> None:
|
|
with open(filename, "rb") as fp:
|
|
image: ImageFile.ImageFile | None = None
|
|
root = os.path.splitext(filename)[0]
|
|
|
|
for ext in (".png", ".gif", ".pbm"):
|
|
if image:
|
|
image.close()
|
|
try:
|
|
fullname = root + ext
|
|
image = Image.open(fullname)
|
|
except Exception:
|
|
pass
|
|
else:
|
|
if image and image.mode in ("1", "L"):
|
|
break
|
|
else:
|
|
if image:
|
|
image.close()
|
|
|
|
msg = f"cannot find glyph data file {root}.{{gif|pbm|png}}"
|
|
raise OSError(msg)
|
|
|
|
self.file = fullname
|
|
|
|
self._load_pilfont_data(fp, image)
|
|
image.close()
|
|
|
|
def _load_pilfont_data(self, file: IO[bytes], image: Image.Image) -> None:
|
|
# read PILfont header
|
|
if file.readline() != b"PILfont\n":
|
|
msg = "Not a PILfont file"
|
|
raise SyntaxError(msg)
|
|
file.readline().split(b";")
|
|
self.info = [] # FIXME: should be a dictionary
|
|
while True:
|
|
s = file.readline()
|
|
if not s or s == b"DATA\n":
|
|
break
|
|
self.info.append(s)
|
|
|
|
# read PILfont metrics
|
|
data = file.read(256 * 20)
|
|
|
|
# check image
|
|
if image.mode not in ("1", "L"):
|
|
msg = "invalid font image mode"
|
|
raise TypeError(msg)
|
|
|
|
image.load()
|
|
|
|
self.font = Image.core.font(image.im, data)
|
|
|
|
def getmask(
|
|
self, text: str | bytes, mode: str = "", *args: Any, **kwargs: Any
|
|
) -> Image.core.ImagingCore:
|
|
"""
|
|
Create a bitmap for the text.
|
|
|
|
If the font uses antialiasing, the bitmap should have mode ``L`` and use a
|
|
maximum value of 255. Otherwise, it should have mode ``1``.
|
|
|
|
:param text: Text to render.
|
|
:param mode: Used by some graphics drivers to indicate what mode the
|
|
driver prefers; if empty, the renderer may return either
|
|
mode. Note that the mode is always a string, to simplify
|
|
C-level implementations.
|
|
|
|
.. versionadded:: 1.1.5
|
|
|
|
:return: An internal PIL storage memory instance as defined by the
|
|
:py:mod:`PIL.Image.core` interface module.
|
|
"""
|
|
_string_length_check(text)
|
|
Image._decompression_bomb_check(self.font.getsize(text))
|
|
return self.font.getmask(text, mode)
|
|
|
|
def getbbox(
|
|
self, text: str | bytes | bytearray, *args: Any, **kwargs: Any
|
|
) -> tuple[int, int, int, int]:
|
|
"""
|
|
Returns bounding box (in pixels) of given text.
|
|
|
|
.. versionadded:: 9.2.0
|
|
|
|
:param text: Text to render.
|
|
|
|
:return: ``(left, top, right, bottom)`` bounding box
|
|
"""
|
|
_string_length_check(text)
|
|
width, height = self.font.getsize(text)
|
|
return 0, 0, width, height
|
|
|
|
def getlength(
|
|
self, text: str | bytes | bytearray, *args: Any, **kwargs: Any
|
|
) -> int:
|
|
"""
|
|
Returns length (in pixels) of given text.
|
|
This is the amount by which following text should be offset.
|
|
|
|
.. versionadded:: 9.2.0
|
|
"""
|
|
_string_length_check(text)
|
|
width, height = self.font.getsize(text)
|
|
return width
|
|
|
|
|
|
##
|
|
# Wrapper for FreeType fonts. Application code should use the
|
|
# <b>truetype</b> factory function to create font objects.
|
|
|
|
|
|
class FreeTypeFont:
|
|
"""FreeType font wrapper (requires _imagingft service)"""
|
|
|
|
font: Font
|
|
font_bytes: bytes
|
|
|
|
def __init__(
|
|
self,
|
|
font: StrOrBytesPath | BinaryIO,
|
|
size: float = 10,
|
|
index: int = 0,
|
|
encoding: str = "",
|
|
layout_engine: Layout | None = None,
|
|
) -> None:
|
|
# FIXME: use service provider instead
|
|
|
|
if isinstance(core, DeferredError):
|
|
raise core.ex
|
|
|
|
if size <= 0:
|
|
msg = f"font size must be greater than 0, not {size}"
|
|
raise ValueError(msg)
|
|
|
|
self.path = font
|
|
self.size = size
|
|
self.index = index
|
|
self.encoding = encoding
|
|
|
|
try:
|
|
from packaging.version import parse as parse_version
|
|
except ImportError:
|
|
pass
|
|
else:
|
|
if freetype_version := features.version_module("freetype2"):
|
|
if parse_version(freetype_version) < parse_version("2.9.1"):
|
|
warnings.warn(
|
|
"Support for FreeType 2.9.0 is deprecated and will be removed "
|
|
"in Pillow 12 (2025-10-15). Please upgrade to FreeType 2.9.1 "
|
|
"or newer, preferably FreeType 2.10.4 which fixes "
|
|
"CVE-2020-15999.",
|
|
DeprecationWarning,
|
|
)
|
|
|
|
if layout_engine not in (Layout.BASIC, Layout.RAQM):
|
|
layout_engine = Layout.BASIC
|
|
if core.HAVE_RAQM:
|
|
layout_engine = Layout.RAQM
|
|
elif layout_engine == Layout.RAQM and not core.HAVE_RAQM:
|
|
warnings.warn(
|
|
"Raqm layout was requested, but Raqm is not available. "
|
|
"Falling back to basic layout."
|
|
)
|
|
layout_engine = Layout.BASIC
|
|
|
|
self.layout_engine = layout_engine
|
|
|
|
def load_from_bytes(f: IO[bytes]) -> None:
|
|
self.font_bytes = f.read()
|
|
self.font = core.getfont(
|
|
"", size, index, encoding, self.font_bytes, layout_engine
|
|
)
|
|
|
|
if is_path(font):
|
|
font = os.path.realpath(os.fspath(font))
|
|
if sys.platform == "win32":
|
|
font_bytes_path = font if isinstance(font, bytes) else font.encode()
|
|
try:
|
|
font_bytes_path.decode("ascii")
|
|
except UnicodeDecodeError:
|
|
# FreeType cannot load fonts with non-ASCII characters on Windows
|
|
# So load it into memory first
|
|
with open(font, "rb") as f:
|
|
load_from_bytes(f)
|
|
return
|
|
self.font = core.getfont(
|
|
font, size, index, encoding, layout_engine=layout_engine
|
|
)
|
|
else:
|
|
load_from_bytes(cast(IO[bytes], font))
|
|
|
|
def __getstate__(self) -> list[Any]:
|
|
return [self.path, self.size, self.index, self.encoding, self.layout_engine]
|
|
|
|
def __setstate__(self, state: list[Any]) -> None:
|
|
path, size, index, encoding, layout_engine = state
|
|
FreeTypeFont.__init__(self, path, size, index, encoding, layout_engine)
|
|
|
|
def getname(self) -> tuple[str | None, str | None]:
|
|
"""
|
|
:return: A tuple of the font family (e.g. Helvetica) and the font style
|
|
(e.g. Bold)
|
|
"""
|
|
return self.font.family, self.font.style
|
|
|
|
def getmetrics(self) -> tuple[int, int]:
|
|
"""
|
|
:return: A tuple of the font ascent (the distance from the baseline to
|
|
the highest outline point) and descent (the distance from the
|
|
baseline to the lowest outline point, a negative value)
|
|
"""
|
|
return self.font.ascent, self.font.descent
|
|
|
|
def getlength(
|
|
self,
|
|
text: str | bytes,
|
|
mode: str = "",
|
|
direction: str | None = None,
|
|
features: list[str] | None = None,
|
|
language: str | None = None,
|
|
) -> float:
|
|
"""
|
|
Returns length (in pixels with 1/64 precision) of given text when rendered
|
|
in font with provided direction, features, and language.
|
|
|
|
This is the amount by which following text should be offset.
|
|
Text bounding box may extend past the length in some fonts,
|
|
e.g. when using italics or accents.
|
|
|
|
The result is returned as a float; it is a whole number if using basic layout.
|
|
|
|
Note that the sum of two lengths may not equal the length of a concatenated
|
|
string due to kerning. If you need to adjust for kerning, include the following
|
|
character and subtract its length.
|
|
|
|
For example, instead of ::
|
|
|
|
hello = font.getlength("Hello")
|
|
world = font.getlength("World")
|
|
hello_world = hello + world # not adjusted for kerning
|
|
assert hello_world == font.getlength("HelloWorld") # may fail
|
|
|
|
use ::
|
|
|
|
hello = font.getlength("HelloW") - font.getlength("W") # adjusted for kerning
|
|
world = font.getlength("World")
|
|
hello_world = hello + world # adjusted for kerning
|
|
assert hello_world == font.getlength("HelloWorld") # True
|
|
|
|
or disable kerning with (requires libraqm) ::
|
|
|
|
hello = draw.textlength("Hello", font, features=["-kern"])
|
|
world = draw.textlength("World", font, features=["-kern"])
|
|
hello_world = hello + world # kerning is disabled, no need to adjust
|
|
assert hello_world == draw.textlength("HelloWorld", font, features=["-kern"])
|
|
|
|
.. versionadded:: 8.0.0
|
|
|
|
:param text: Text to measure.
|
|
:param mode: Used by some graphics drivers to indicate what mode the
|
|
driver prefers; if empty, the renderer may return either
|
|
mode. Note that the mode is always a string, to simplify
|
|
C-level implementations.
|
|
|
|
:param direction: Direction of the text. It can be 'rtl' (right to
|
|
left), 'ltr' (left to right) or 'ttb' (top to bottom).
|
|
Requires libraqm.
|
|
|
|
:param features: A list of OpenType font features to be used during text
|
|
layout. This is usually used to turn on optional
|
|
font features that are not enabled by default,
|
|
for example 'dlig' or 'ss01', but can be also
|
|
used to turn off default font features for
|
|
example '-liga' to disable ligatures or '-kern'
|
|
to disable kerning. To get all supported
|
|
features, see
|
|
https://learn.microsoft.com/en-us/typography/opentype/spec/featurelist
|
|
Requires libraqm.
|
|
|
|
:param language: Language of the text. Different languages may use
|
|
different glyph shapes or ligatures. This parameter tells
|
|
the font which language the text is in, and to apply the
|
|
correct substitutions as appropriate, if available.
|
|
It should be a `BCP 47 language code
|
|
<https://www.w3.org/International/articles/language-tags/>`_
|
|
Requires libraqm.
|
|
|
|
:return: Either width for horizontal text, or height for vertical text.
|
|
"""
|
|
_string_length_check(text)
|
|
return self.font.getlength(text, mode, direction, features, language) / 64
|
|
|
|
def getbbox(
|
|
self,
|
|
text: str | bytes,
|
|
mode: str = "",
|
|
direction: str | None = None,
|
|
features: list[str] | None = None,
|
|
language: str | None = None,
|
|
stroke_width: float = 0,
|
|
anchor: str | None = None,
|
|
) -> tuple[float, float, float, float]:
|
|
"""
|
|
Returns bounding box (in pixels) of given text relative to given anchor
|
|
when rendered in font with provided direction, features, and language.
|
|
|
|
Use :py:meth:`getlength()` to get the offset of following text with
|
|
1/64 pixel precision. The bounding box includes extra margins for
|
|
some fonts, e.g. italics or accents.
|
|
|
|
.. versionadded:: 8.0.0
|
|
|
|
:param text: Text to render.
|
|
:param mode: Used by some graphics drivers to indicate what mode the
|
|
driver prefers; if empty, the renderer may return either
|
|
mode. Note that the mode is always a string, to simplify
|
|
C-level implementations.
|
|
|
|
:param direction: Direction of the text. It can be 'rtl' (right to
|
|
left), 'ltr' (left to right) or 'ttb' (top to bottom).
|
|
Requires libraqm.
|
|
|
|
:param features: A list of OpenType font features to be used during text
|
|
layout. This is usually used to turn on optional
|
|
font features that are not enabled by default,
|
|
for example 'dlig' or 'ss01', but can be also
|
|
used to turn off default font features for
|
|
example '-liga' to disable ligatures or '-kern'
|
|
to disable kerning. To get all supported
|
|
features, see
|
|
https://learn.microsoft.com/en-us/typography/opentype/spec/featurelist
|
|
Requires libraqm.
|
|
|
|
:param language: Language of the text. Different languages may use
|
|
different glyph shapes or ligatures. This parameter tells
|
|
the font which language the text is in, and to apply the
|
|
correct substitutions as appropriate, if available.
|
|
It should be a `BCP 47 language code
|
|
<https://www.w3.org/International/articles/language-tags/>`_
|
|
Requires libraqm.
|
|
|
|
:param stroke_width: The width of the text stroke.
|
|
|
|
:param anchor: The text anchor alignment. Determines the relative location of
|
|
the anchor to the text. The default alignment is top left,
|
|
specifically ``la`` for horizontal text and ``lt`` for
|
|
vertical text. See :ref:`text-anchors` for details.
|
|
|
|
:return: ``(left, top, right, bottom)`` bounding box
|
|
"""
|
|
_string_length_check(text)
|
|
size, offset = self.font.getsize(
|
|
text, mode, direction, features, language, anchor
|
|
)
|
|
left, top = offset[0] - stroke_width, offset[1] - stroke_width
|
|
width, height = size[0] + 2 * stroke_width, size[1] + 2 * stroke_width
|
|
return left, top, left + width, top + height
|
|
|
|
def getmask(
|
|
self,
|
|
text: str | bytes,
|
|
mode: str = "",
|
|
direction: str | None = None,
|
|
features: list[str] | None = None,
|
|
language: str | None = None,
|
|
stroke_width: float = 0,
|
|
anchor: str | None = None,
|
|
ink: int = 0,
|
|
start: tuple[float, float] | None = None,
|
|
) -> Image.core.ImagingCore:
|
|
"""
|
|
Create a bitmap for the text.
|
|
|
|
If the font uses antialiasing, the bitmap should have mode ``L`` and use a
|
|
maximum value of 255. If the font has embedded color data, the bitmap
|
|
should have mode ``RGBA``. Otherwise, it should have mode ``1``.
|
|
|
|
:param text: Text to render.
|
|
:param mode: Used by some graphics drivers to indicate what mode the
|
|
driver prefers; if empty, the renderer may return either
|
|
mode. Note that the mode is always a string, to simplify
|
|
C-level implementations.
|
|
|
|
.. versionadded:: 1.1.5
|
|
|
|
:param direction: Direction of the text. It can be 'rtl' (right to
|
|
left), 'ltr' (left to right) or 'ttb' (top to bottom).
|
|
Requires libraqm.
|
|
|
|
.. versionadded:: 4.2.0
|
|
|
|
:param features: A list of OpenType font features to be used during text
|
|
layout. This is usually used to turn on optional
|
|
font features that are not enabled by default,
|
|
for example 'dlig' or 'ss01', but can be also
|
|
used to turn off default font features for
|
|
example '-liga' to disable ligatures or '-kern'
|
|
to disable kerning. To get all supported
|
|
features, see
|
|
https://learn.microsoft.com/en-us/typography/opentype/spec/featurelist
|
|
Requires libraqm.
|
|
|
|
.. versionadded:: 4.2.0
|
|
|
|
:param language: Language of the text. Different languages may use
|
|
different glyph shapes or ligatures. This parameter tells
|
|
the font which language the text is in, and to apply the
|
|
correct substitutions as appropriate, if available.
|
|
It should be a `BCP 47 language code
|
|
<https://www.w3.org/International/articles/language-tags/>`_
|
|
Requires libraqm.
|
|
|
|
.. versionadded:: 6.0.0
|
|
|
|
:param stroke_width: The width of the text stroke.
|
|
|
|
.. versionadded:: 6.2.0
|
|
|
|
:param anchor: The text anchor alignment. Determines the relative location of
|
|
the anchor to the text. The default alignment is top left,
|
|
specifically ``la`` for horizontal text and ``lt`` for
|
|
vertical text. See :ref:`text-anchors` for details.
|
|
|
|
.. versionadded:: 8.0.0
|
|
|
|
:param ink: Foreground ink for rendering in RGBA mode.
|
|
|
|
.. versionadded:: 8.0.0
|
|
|
|
:param start: Tuple of horizontal and vertical offset, as text may render
|
|
differently when starting at fractional coordinates.
|
|
|
|
.. versionadded:: 9.4.0
|
|
|
|
:return: An internal PIL storage memory instance as defined by the
|
|
:py:mod:`PIL.Image.core` interface module.
|
|
"""
|
|
return self.getmask2(
|
|
text,
|
|
mode,
|
|
direction=direction,
|
|
features=features,
|
|
language=language,
|
|
stroke_width=stroke_width,
|
|
anchor=anchor,
|
|
ink=ink,
|
|
start=start,
|
|
)[0]
|
|
|
|
def getmask2(
|
|
self,
|
|
text: str | bytes,
|
|
mode: str = "",
|
|
direction: str | None = None,
|
|
features: list[str] | None = None,
|
|
language: str | None = None,
|
|
stroke_width: float = 0,
|
|
anchor: str | None = None,
|
|
ink: int = 0,
|
|
start: tuple[float, float] | None = None,
|
|
*args: Any,
|
|
**kwargs: Any,
|
|
) -> tuple[Image.core.ImagingCore, tuple[int, int]]:
|
|
"""
|
|
Create a bitmap for the text.
|
|
|
|
If the font uses antialiasing, the bitmap should have mode ``L`` and use a
|
|
maximum value of 255. If the font has embedded color data, the bitmap
|
|
should have mode ``RGBA``. Otherwise, it should have mode ``1``.
|
|
|
|
:param text: Text to render.
|
|
:param mode: Used by some graphics drivers to indicate what mode the
|
|
driver prefers; if empty, the renderer may return either
|
|
mode. Note that the mode is always a string, to simplify
|
|
C-level implementations.
|
|
|
|
.. versionadded:: 1.1.5
|
|
|
|
:param direction: Direction of the text. It can be 'rtl' (right to
|
|
left), 'ltr' (left to right) or 'ttb' (top to bottom).
|
|
Requires libraqm.
|
|
|
|
.. versionadded:: 4.2.0
|
|
|
|
:param features: A list of OpenType font features to be used during text
|
|
layout. This is usually used to turn on optional
|
|
font features that are not enabled by default,
|
|
for example 'dlig' or 'ss01', but can be also
|
|
used to turn off default font features for
|
|
example '-liga' to disable ligatures or '-kern'
|
|
to disable kerning. To get all supported
|
|
features, see
|
|
https://learn.microsoft.com/en-us/typography/opentype/spec/featurelist
|
|
Requires libraqm.
|
|
|
|
.. versionadded:: 4.2.0
|
|
|
|
:param language: Language of the text. Different languages may use
|
|
different glyph shapes or ligatures. This parameter tells
|
|
the font which language the text is in, and to apply the
|
|
correct substitutions as appropriate, if available.
|
|
It should be a `BCP 47 language code
|
|
<https://www.w3.org/International/articles/language-tags/>`_
|
|
Requires libraqm.
|
|
|
|
.. versionadded:: 6.0.0
|
|
|
|
:param stroke_width: The width of the text stroke.
|
|
|
|
.. versionadded:: 6.2.0
|
|
|
|
:param anchor: The text anchor alignment. Determines the relative location of
|
|
the anchor to the text. The default alignment is top left,
|
|
specifically ``la`` for horizontal text and ``lt`` for
|
|
vertical text. See :ref:`text-anchors` for details.
|
|
|
|
.. versionadded:: 8.0.0
|
|
|
|
:param ink: Foreground ink for rendering in RGBA mode.
|
|
|
|
.. versionadded:: 8.0.0
|
|
|
|
:param start: Tuple of horizontal and vertical offset, as text may render
|
|
differently when starting at fractional coordinates.
|
|
|
|
.. versionadded:: 9.4.0
|
|
|
|
:return: A tuple of an internal PIL storage memory instance as defined by the
|
|
:py:mod:`PIL.Image.core` interface module, and the text offset, the
|
|
gap between the starting coordinate and the first marking
|
|
"""
|
|
_string_length_check(text)
|
|
if start is None:
|
|
start = (0, 0)
|
|
|
|
def fill(width: int, height: int) -> Image.core.ImagingCore:
|
|
size = (width, height)
|
|
Image._decompression_bomb_check(size)
|
|
return Image.core.fill("RGBA" if mode == "RGBA" else "L", size)
|
|
|
|
return self.font.render(
|
|
text,
|
|
fill,
|
|
mode,
|
|
direction,
|
|
features,
|
|
language,
|
|
stroke_width,
|
|
anchor,
|
|
ink,
|
|
start[0],
|
|
start[1],
|
|
)
|
|
|
|
def font_variant(
|
|
self,
|
|
font: StrOrBytesPath | BinaryIO | None = None,
|
|
size: float | None = None,
|
|
index: int | None = None,
|
|
encoding: str | None = None,
|
|
layout_engine: Layout | None = None,
|
|
) -> FreeTypeFont:
|
|
"""
|
|
Create a copy of this FreeTypeFont object,
|
|
using any specified arguments to override the settings.
|
|
|
|
Parameters are identical to the parameters used to initialize this
|
|
object.
|
|
|
|
:return: A FreeTypeFont object.
|
|
"""
|
|
if font is None:
|
|
try:
|
|
font = BytesIO(self.font_bytes)
|
|
except AttributeError:
|
|
font = self.path
|
|
return FreeTypeFont(
|
|
font=font,
|
|
size=self.size if size is None else size,
|
|
index=self.index if index is None else index,
|
|
encoding=self.encoding if encoding is None else encoding,
|
|
layout_engine=layout_engine or self.layout_engine,
|
|
)
|
|
|
|
def get_variation_names(self) -> list[bytes]:
|
|
"""
|
|
:returns: A list of the named styles in a variation font.
|
|
:exception OSError: If the font is not a variation font.
|
|
"""
|
|
try:
|
|
names = self.font.getvarnames()
|
|
except AttributeError as e:
|
|
msg = "FreeType 2.9.1 or greater is required"
|
|
raise NotImplementedError(msg) from e
|
|
return [name.replace(b"\x00", b"") for name in names]
|
|
|
|
def set_variation_by_name(self, name: str | bytes) -> None:
|
|
"""
|
|
:param name: The name of the style.
|
|
:exception OSError: If the font is not a variation font.
|
|
"""
|
|
names = self.get_variation_names()
|
|
if not isinstance(name, bytes):
|
|
name = name.encode()
|
|
index = names.index(name) + 1
|
|
|
|
if index == getattr(self, "_last_variation_index", None):
|
|
# When the same name is set twice in a row,
|
|
# there is an 'unknown freetype error'
|
|
# https://savannah.nongnu.org/bugs/?56186
|
|
return
|
|
self._last_variation_index = index
|
|
|
|
self.font.setvarname(index)
|
|
|
|
def get_variation_axes(self) -> list[Axis]:
|
|
"""
|
|
:returns: A list of the axes in a variation font.
|
|
:exception OSError: If the font is not a variation font.
|
|
"""
|
|
try:
|
|
axes = self.font.getvaraxes()
|
|
except AttributeError as e:
|
|
msg = "FreeType 2.9.1 or greater is required"
|
|
raise NotImplementedError(msg) from e
|
|
for axis in axes:
|
|
if axis["name"]:
|
|
axis["name"] = axis["name"].replace(b"\x00", b"")
|
|
return axes
|
|
|
|
def set_variation_by_axes(self, axes: list[float]) -> None:
|
|
"""
|
|
:param axes: A list of values for each axis.
|
|
:exception OSError: If the font is not a variation font.
|
|
"""
|
|
try:
|
|
self.font.setvaraxes(axes)
|
|
except AttributeError as e:
|
|
msg = "FreeType 2.9.1 or greater is required"
|
|
raise NotImplementedError(msg) from e
|
|
|
|
|
|
class TransposedFont:
|
|
"""Wrapper for writing rotated or mirrored text"""
|
|
|
|
def __init__(
|
|
self, font: ImageFont | FreeTypeFont, orientation: Image.Transpose | None = None
|
|
):
|
|
"""
|
|
Wrapper that creates a transposed font from any existing font
|
|
object.
|
|
|
|
:param font: A font object.
|
|
:param orientation: An optional orientation. If given, this should
|
|
be one of Image.Transpose.FLIP_LEFT_RIGHT, Image.Transpose.FLIP_TOP_BOTTOM,
|
|
Image.Transpose.ROTATE_90, Image.Transpose.ROTATE_180, or
|
|
Image.Transpose.ROTATE_270.
|
|
"""
|
|
self.font = font
|
|
self.orientation = orientation # any 'transpose' argument, or None
|
|
|
|
def getmask(
|
|
self, text: str | bytes, mode: str = "", *args: Any, **kwargs: Any
|
|
) -> Image.core.ImagingCore:
|
|
im = self.font.getmask(text, mode, *args, **kwargs)
|
|
if self.orientation is not None:
|
|
return im.transpose(self.orientation)
|
|
return im
|
|
|
|
def getbbox(
|
|
self, text: str | bytes, *args: Any, **kwargs: Any
|
|
) -> tuple[int, int, float, float]:
|
|
# TransposedFont doesn't support getmask2, move top-left point to (0, 0)
|
|
# this has no effect on ImageFont and simulates anchor="lt" for FreeTypeFont
|
|
left, top, right, bottom = self.font.getbbox(text, *args, **kwargs)
|
|
width = right - left
|
|
height = bottom - top
|
|
if self.orientation in (Image.Transpose.ROTATE_90, Image.Transpose.ROTATE_270):
|
|
return 0, 0, height, width
|
|
return 0, 0, width, height
|
|
|
|
def getlength(self, text: str | bytes, *args: Any, **kwargs: Any) -> float:
|
|
if self.orientation in (Image.Transpose.ROTATE_90, Image.Transpose.ROTATE_270):
|
|
msg = "text length is undefined for text rotated by 90 or 270 degrees"
|
|
raise ValueError(msg)
|
|
return self.font.getlength(text, *args, **kwargs)
|
|
|
|
|
|
def load(filename: str) -> ImageFont:
|
|
"""
|
|
Load a font file. This function loads a font object from the given
|
|
bitmap font file, and returns the corresponding font object. For loading TrueType
|
|
or OpenType fonts instead, see :py:func:`~PIL.ImageFont.truetype`.
|
|
|
|
:param filename: Name of font file.
|
|
:return: A font object.
|
|
:exception OSError: If the file could not be read.
|
|
"""
|
|
f = ImageFont()
|
|
f._load_pilfont(filename)
|
|
return f
|
|
|
|
|
|
def truetype(
|
|
font: StrOrBytesPath | BinaryIO,
|
|
size: float = 10,
|
|
index: int = 0,
|
|
encoding: str = "",
|
|
layout_engine: Layout | None = None,
|
|
) -> FreeTypeFont:
|
|
"""
|
|
Load a TrueType or OpenType font from a file or file-like object,
|
|
and create a font object. This function loads a font object from the given
|
|
file or file-like object, and creates a font object for a font of the given
|
|
size. For loading bitmap fonts instead, see :py:func:`~PIL.ImageFont.load`
|
|
and :py:func:`~PIL.ImageFont.load_path`.
|
|
|
|
Pillow uses FreeType to open font files. On Windows, be aware that FreeType
|
|
will keep the file open as long as the FreeTypeFont object exists. Windows
|
|
limits the number of files that can be open in C at once to 512, so if many
|
|
fonts are opened simultaneously and that limit is approached, an
|
|
``OSError`` may be thrown, reporting that FreeType "cannot open resource".
|
|
A workaround would be to copy the file(s) into memory, and open that instead.
|
|
|
|
This function requires the _imagingft service.
|
|
|
|
:param font: A filename or file-like object containing a TrueType font.
|
|
If the file is not found in this filename, the loader may also
|
|
search in other directories, such as:
|
|
|
|
* The :file:`fonts/` directory on Windows,
|
|
* :file:`/Library/Fonts/`, :file:`/System/Library/Fonts/`
|
|
and :file:`~/Library/Fonts/` on macOS.
|
|
* :file:`~/.local/share/fonts`, :file:`/usr/local/share/fonts`,
|
|
and :file:`/usr/share/fonts` on Linux; or those specified by
|
|
the ``XDG_DATA_HOME`` and ``XDG_DATA_DIRS`` environment variables
|
|
for user-installed and system-wide fonts, respectively.
|
|
|
|
:param size: The requested size, in pixels.
|
|
:param index: Which font face to load (default is first available face).
|
|
:param encoding: Which font encoding to use (default is Unicode). Possible
|
|
encodings include (see the FreeType documentation for more
|
|
information):
|
|
|
|
* "unic" (Unicode)
|
|
* "symb" (Microsoft Symbol)
|
|
* "ADOB" (Adobe Standard)
|
|
* "ADBE" (Adobe Expert)
|
|
* "ADBC" (Adobe Custom)
|
|
* "armn" (Apple Roman)
|
|
* "sjis" (Shift JIS)
|
|
* "gb " (PRC)
|
|
* "big5"
|
|
* "wans" (Extended Wansung)
|
|
* "joha" (Johab)
|
|
* "lat1" (Latin-1)
|
|
|
|
This specifies the character set to use. It does not alter the
|
|
encoding of any text provided in subsequent operations.
|
|
:param layout_engine: Which layout engine to use, if available:
|
|
:attr:`.ImageFont.Layout.BASIC` or :attr:`.ImageFont.Layout.RAQM`.
|
|
If it is available, Raqm layout will be used by default.
|
|
Otherwise, basic layout will be used.
|
|
|
|
Raqm layout is recommended for all non-English text. If Raqm layout
|
|
is not required, basic layout will have better performance.
|
|
|
|
You can check support for Raqm layout using
|
|
:py:func:`PIL.features.check_feature` with ``feature="raqm"``.
|
|
|
|
.. versionadded:: 4.2.0
|
|
:return: A font object.
|
|
:exception OSError: If the file could not be read.
|
|
:exception ValueError: If the font size is not greater than zero.
|
|
"""
|
|
|
|
def freetype(font: StrOrBytesPath | BinaryIO) -> FreeTypeFont:
|
|
return FreeTypeFont(font, size, index, encoding, layout_engine)
|
|
|
|
try:
|
|
return freetype(font)
|
|
except OSError:
|
|
if not is_path(font):
|
|
raise
|
|
ttf_filename = os.path.basename(font)
|
|
|
|
dirs = []
|
|
if sys.platform == "win32":
|
|
# check the windows font repository
|
|
# NOTE: must use uppercase WINDIR, to work around bugs in
|
|
# 1.5.2's os***REMOVED***iron.get()
|
|
windir = os***REMOVED***iron.get("WINDIR")
|
|
if windir:
|
|
dirs.append(os.path.join(windir, "fonts"))
|
|
elif sys.platform in ("linux", "linux2"):
|
|
data_home = os***REMOVED***iron.get("XDG_DATA_HOME")
|
|
if not data_home:
|
|
# The freedesktop spec defines the following default directory for
|
|
# when XDG_DATA_HOME is unset or empty. This user-level directory
|
|
# takes precedence over system-level directories.
|
|
data_home = os.path.expanduser("~/.local/share")
|
|
xdg_dirs = [data_home]
|
|
|
|
data_dirs = os***REMOVED***iron.get("XDG_DATA_DIRS")
|
|
if not data_dirs:
|
|
# Similarly, defaults are defined for the system-level directories
|
|
data_dirs = "/usr/local/share:/usr/share"
|
|
xdg_dirs += data_dirs.split(":")
|
|
|
|
dirs += [os.path.join(xdg_dir, "fonts") for xdg_dir in xdg_dirs]
|
|
elif sys.platform == "darwin":
|
|
dirs += [
|
|
"/Library/Fonts",
|
|
"/System/Library/Fonts",
|
|
os.path.expanduser("~/Library/Fonts"),
|
|
]
|
|
|
|
ext = os.path.splitext(ttf_filename)[1]
|
|
first_font_with_a_different_extension = None
|
|
for directory in dirs:
|
|
for walkroot, walkdir, walkfilenames in os.walk(directory):
|
|
for walkfilename in walkfilenames:
|
|
if ext and walkfilename == ttf_filename:
|
|
return freetype(os.path.join(walkroot, walkfilename))
|
|
elif not ext and os.path.splitext(walkfilename)[0] == ttf_filename:
|
|
fontpath = os.path.join(walkroot, walkfilename)
|
|
if os.path.splitext(fontpath)[1] == ".ttf":
|
|
return freetype(fontpath)
|
|
if not ext and first_font_with_a_different_extension is None:
|
|
first_font_with_a_different_extension = fontpath
|
|
if first_font_with_a_different_extension:
|
|
return freetype(first_font_with_a_different_extension)
|
|
raise
|
|
|
|
|
|
def load_path(filename: str | bytes) -> ImageFont:
|
|
"""
|
|
Load font file. Same as :py:func:`~PIL.ImageFont.load`, but searches for a
|
|
bitmap font along the Python path.
|
|
|
|
:param filename: Name of font file.
|
|
:return: A font object.
|
|
:exception OSError: If the file could not be read.
|
|
"""
|
|
if not isinstance(filename, str):
|
|
filename = filename.decode("utf-8")
|
|
for directory in sys.path:
|
|
try:
|
|
return load(os.path.join(directory, filename))
|
|
except OSError:
|
|
pass
|
|
msg = f'cannot find font file "{filename}" in sys.path'
|
|
if os.path.exists(filename):
|
|
msg += f', did you mean ImageFont.load("{filename}") instead?'
|
|
|
|
raise OSError(msg)
|
|
|
|
|
|
def load_default_imagefont() -> ImageFont:
|
|
f = ImageFont()
|
|
f._load_pilfont_data(
|
|
# courB08
|
|
BytesIO(
|
|
base64.b64decode(
|
|
b"""
|
|
[AWS-SECRET-REMOVED]AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
|
|
[AWS-SECRET-REMOVED]AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
|
|
[AWS-SECRET-REMOVED]AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
|
|
[AWS-SECRET-REMOVED]AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
|
|
[AWS-SECRET-REMOVED]AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
|
|
[AWS-SECRET-REMOVED]AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
|
|
[AWS-SECRET-REMOVED]AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
|
|
[AWS-SECRET-REMOVED]AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
|
|
[AWS-SECRET-REMOVED]AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
|
|
[AWS-SECRET-REMOVED]AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
|
|
[AWS-SECRET-REMOVED]AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
|
|
[AWS-SECRET-REMOVED]AAAAAAAAAAYAAAAA//8AAQAAAAAAAAABAAEA
|
|
[AWS-SECRET-REMOVED]/QADAAAABgADAAYAAAAA//kABQABAAYAAAAL
|
|
[AWS-SECRET-REMOVED]AAUAAAAQAAAAFQAHAAYAAP////oABQAAABUA
|
|
[AWS-SECRET-REMOVED]Af/5AAQAAQAeAAAAIQAIAAYAAAAB//kABAAB
|
|
[AWS-SECRET-REMOVED]AAAAAP/6AAX//wAoAAAALQAFAAYAAAAB//8A
|
|
[AWS-SECRET-REMOVED]AQAGAAAAAf//AAMAAAA1AAAANwABAAYAAAAB
|
|
[AWS-SECRET-REMOVED]AEAABwAGAAAAAP/5AAYAAABAAAAARgAHAAYA
|
|
[AWS-SECRET-REMOVED]SwAAAFAABwAGAAAAAP/5AAYAAABQAAAAVgAH
|
|
[AWS-SECRET-REMOVED]AAAAWwAAAGAABwAGAAAAAP/5AAUAAABgAAAA
|
|
[AWS-SECRET-REMOVED]+QAFAAAAagAAAG8ABwAGAAAAAf/8AAMAAABv
|
|
[AWS-SECRET-REMOVED]AAD/+gAE//8AdAAAAHgABQAGAAAAAP/7AAT/
|
|
[AWS-SECRET-REMOVED]BgAAAAD/+gAFAAAAgAAAAIUABgAGAAAAAP/5
|
|
[AWS-SECRET-REMOVED]AAYABgAA////+gAFAAAAkgAAAJgABgAGAAAA
|
|
[AWS-SECRET-REMOVED]AACjAAYABgAA////+gAFAAAAowAAAKkABgAG
|
|
[AWS-SECRET-REMOVED]AK8AAAC0AAYABgAA////+gAGAAAAtAAAALsA
|
|
[AWS-SECRET-REMOVED]BQAAAL8AAADFAAYABgAA////+gAGAAAAxQAA
|
|
[AWS-SECRET-REMOVED]//oABQAAANIAAADYAAYABgAA////+gAGAAAA
|
|
[AWS-SECRET-REMOVED]AP////oABQAAAOQAAADqAAYABgAAAAD/+gAF
|
|
[AWS-SECRET-REMOVED]AAYAAAAA//oABQAAAPYAAAD7AAYABgAA////
|
|
[AWS-SECRET-REMOVED]CAAGAAYAAP////oABgAAAQgAAAEPAAYABgAA
|
|
[AWS-SECRET-REMOVED]AAABHAAGAAYAAP////oABgAAARwAAAEjAAYA
|
|
[AWS-SECRET-REMOVED]AQEoAAABKwAIAAYAAAAA//kABAABASsAAAEv
|
|
[AWS-SECRET-REMOVED]AAX//AEyAAABNwADAAYAAAAAAAEABgACATcA
|
|
[AWS-SECRET-REMOVED]AP/7AAYAAAFAAAABRgAFAAYAAP////kABQAA
|
|
[AWS-SECRET-REMOVED]AAAAAP/5AAYAAAFRAAABVwAHAAYAAAAA//sA
|
|
[AWS-SECRET-REMOVED]BwAGAAAAAP/7AAYAAgFhAAABZwAHAAYAAP//
|
|
[AWS-SECRET-REMOVED]AXMABwAGAAAAAP/5AAQAAgFzAAABdwAJAAYA
|
|
[AWS-SECRET-REMOVED]fgAAAYQABwAGAAD////7AAUAAAGEAAABigAF
|
|
[AWS-SECRET-REMOVED]AAABkAAAAZUABQAGAAD////7AAUAAgGVAAAB
|
|
[AWS-SECRET-REMOVED]+wAGAAABoQAAAacABQAGAAAAAP/7AAYAAAGn
|
|
[AWS-SECRET-REMOVED]////+wAGAAABswAAAboABQAGAAD////7AAUA
|
|
[AWS-SECRET-REMOVED]BgAAAAD/+wAGAAABxwAAAc0ABQAGAAD////7
|
|
[AWS-SECRET-REMOVED]AAUABgAAAAH/+QAFAAEB2QAAAd0ACAAGAAAA
|
|
[AWS-SECRET-REMOVED]AAHiAAgABgAAAAD/+wAF//0B4gAAAecAAgAA
|
|
[AWS-SECRET-REMOVED]AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
|
|
[AWS-SECRET-REMOVED]AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
|
|
[AWS-SECRET-REMOVED]AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
|
|
[AWS-SECRET-REMOVED]AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
|
|
[AWS-SECRET-REMOVED]AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
|
|
[AWS-SECRET-REMOVED]AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
|
|
[AWS-SECRET-REMOVED]AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
|
|
[AWS-SECRET-REMOVED]AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
|
|
[AWS-SECRET-REMOVED]AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
|
|
[AWS-SECRET-REMOVED]AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
|
|
[AWS-SECRET-REMOVED]AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
|
|
[AWS-SECRET-REMOVED]AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYAAAAB
|
|
[AWS-SECRET-REMOVED]Ae4ACAAGAAAAAP/5AAYAAAHuAAAB9AAHAAYA
|
|
[AWS-SECRET-REMOVED]+QAAAf8ABwAGAAAAAv/5AAMAAgH/AAACAAAJ
|
|
[AWS-SECRET-REMOVED]//sCBQAAAggAAQAGAAAAAP/5AAYAAAIIAAAC
|
|
[AWS-SECRET-REMOVED]+wAGAAACEgAAAhkABQAGAAAAAP/7AAX//gIZ
|
|
[AWS-SECRET-REMOVED]AAD/+QAHAAACIwAAAioABwAGAAAAAP/6AAT/
|
|
[AWS-SECRET-REMOVED]BgAAAAD/+gAFAAACMgAAAjcABgAGAAAAAf/5
|
|
[AWS-SECRET-REMOVED]AAQABgAAAAL/+QAE//sCPQAAAj8AAgAGAAD/
|
|
[AWS-SECRET-REMOVED]AAJMAAgABgAAAAH//AAD//0CTAAAAk4AAQAG
|
|
[AWS-SECRET-REMOVED]AlEAAAJUAAQABgAAAAH/+QAF//4CVAAAAlgA
|
|
[AWS-SECRET-REMOVED]BgAAAl8AAAJmAAcABgAA////+QAGAAACZgAA
|
|
[AWS-SECRET-REMOVED]//sABQACAnQAAAJ5AAcABgAA////9wAGAAAC
|
|
[AWS-SECRET-REMOVED]AP////cABgAAAocAAAKOAAkABgAA////9wAG
|
|
[AWS-SECRET-REMOVED]AAYAAP////cABgAAApwAAAKjAAkABgAA////
|
|
[AWS-SECRET-REMOVED]rwAIAAYAAP////cABQAAAq8AAAK1AAkABgAA
|
|
[AWS-SECRET-REMOVED]AAACwQAJAAYAAP////gABQAAAsEAAALHAAgA
|
|
[AWS-SECRET-REMOVED]AALLAAACzwAJAAYAAAAA//cABAAAAs8AAALT
|
|
[AWS-SECRET-REMOVED]AAUAAALXAAAC3QAGAAYAAP////cABgAAAt0A
|
|
[AWS-SECRET-REMOVED]AP/3AAUAAALpAAAC7gAJAAYAAAAA//cABQAA
|
|
[AWS-SECRET-REMOVED]AAAAAP/4AAUAAAL4AAAC/QAIAAYAAAAA//oA
|
|
[AWS-SECRET-REMOVED]BgAGAAD////3AAYAAAMJAAADEAAJAAYAAP//
|
|
[AWS-SECRET-REMOVED]Ax4ACQAGAAD////4AAYAAAAAAAoABwASAAYA
|
|
[AWS-SECRET-REMOVED]DgAKABQAEAAGAAD////6AAYAAAAUAAoAGwAQ
|
|
[AWS-SECRET-REMOVED]AAAAIQAKACcAEgAGAAAAAP/4AAYAAAAnAAoA
|
|
[AWS-SECRET-REMOVED]+QAGAAAAMwAKADkAEQAGAAAAAP/3AAYAAAA5
|
|
[AWS-SECRET-REMOVED]AAD/+wAFAAIARQAKAEoAEQAGAAAAAP/4AAUA
|
|
[AWS-SECRET-REMOVED]BgAAAAD/+AAFAAAAVAAKAFkAEgAGAAAAAP/5
|
|
[AWS-SECRET-REMOVED]ABIABgAAAAD/+AAGAAAAZAAKAGoAEgAGAAAA
|
|
[AWS-SECRET-REMOVED]CgB2ABEABgAAAAD/+AAFAAAAdgAKAHsAEgAG
|
|
[AWS-SECRET-REMOVED]AIIACgCHABIABgAAAAD/+AAFAAAAhwAKAIwA
|
|
[AWS-SECRET-REMOVED]BQAAAJEACgCWABIABgAAAAD/+QAFAAAAlgAK
|
|
[AWS-SECRET-REMOVED]//oABQABAKAACgClABEABgAA////+AAGAAAA
|
|
[AWS-SECRET-REMOVED]AP////gABgAAALMACgC6ABIABgAA////+QAG
|
|
[AWS-SECRET-REMOVED]AAYAAP////kABQACAMgACgDOABMABgAA////
|
|
+QAGAAIAzgAKANUAEw==
|
|
"""
|
|
)
|
|
),
|
|
Image.open(
|
|
BytesIO(
|
|
base64.b64decode(
|
|
b"""
|
|
[AWS-SECRET-REMOVED]MtZoAAAEwElEQVR4nABlAJr/AHVE4czCI/4u
|
|
[AWS-SECRET-REMOVED]yf5zhxzjt8GHw8+2d83u8x27199/nxuQ6Od9
|
|
[AWS-SECRET-REMOVED]VE6QCCAAAAD//wBlAJr/AgALyj1t/wINwq0g
|
|
[AWS-SECRET-REMOVED]BnHTtf95/fglZK5N0PDgfRTslpGBvz7LFc4F
|
|
[AWS-SECRET-REMOVED]CDAAAAD//wBlAJr/AgKqRooH2gAgPeggvUAA
|
|
[AWS-SECRET-REMOVED]gDeeGP6AAAD1NMDzKHD7ANWr3loYbxsAD791
|
|
[AWS-SECRET-REMOVED]AAD//wBlAJr/AuplMlADJAAAAGuAphWpqhMx
|
|
[AWS-SECRET-REMOVED]GAAAAAAAREAAwI7nr0ArYpow7aX8//9LaP/9
|
|
[AWS-SECRET-REMOVED]/wBlAJr/AqDxW+D3AABAAbUh/QMnbQag/gAY
|
|
[AWS-SECRET-REMOVED]mFRJuPo27ciC0cD5oeW4E7KA/wD3ECMAn2tt
|
|
[AWS-SECRET-REMOVED]AJr/BGKAyCAA4AAAAvgeYTAwHd1kmQF5chkG
|
|
[AWS-SECRET-REMOVED]il08AEh/tUzdCBsXkbgACED+woQg8Si9VeqY
|
|
[AWS-SECRET-REMOVED]VGBg5Pv/Tvpc8hwGBjYGJADjHDrAwPzAjv/H
|
|
[AWS-SECRET-REMOVED]BgYOC3W7mp+f0w+wHOYxO3OG+e376hsMZjk3
|
|
[AWS-SECRET-REMOVED]gzSDAAPjByiHcQMDAwMDg1nOze1lByRu5/47
|
|
[AWS-SECRET-REMOVED]L39/fwffA8b//xv/P2BPtzzHwCBjUQAAAAD/
|
|
[AWS-SECRET-REMOVED]bfrMf/QHI8evOwcSqGUJAAAA//9iYBB81iSw
|
|
[AWS-SECRET-REMOVED]x7j9AAMDn8Q/BgYLBoaiAwwMjPdvMDBYM1Tv
|
|
[AWS-SECRET-REMOVED]qlE9725C+acfVLMEAAAA//9i+s9gwCoaaGMR
|
|
[AWS-SECRET-REMOVED]WLci5v1+HmFXDqcnULE/MxgYGBj+f6CaJQAA
|
|
[AWS-SECRET-REMOVED]cTwOVLMEAAAA//9isDBgkP///0EOg9z35v//
|
|
[AWS-SECRET-REMOVED]qEMXlvhMPUsAAAAA//8iYDd1AAAAAP//AwDR
|
|
w7IkEbzhVQAAAABJRU5ErkJggg==
|
|
"""
|
|
)
|
|
)
|
|
),
|
|
)
|
|
return f
|
|
|
|
|
|
def load_default(size: float | None = None) -> FreeTypeFont | ImageFont:
|
|
"""If FreeType support is available, load a version of Aileron Regular,
|
|
https://dotcolon.net/font/aileron, with a more limited character set.
|
|
|
|
Otherwise, load a "better than nothing" font.
|
|
|
|
.. versionadded:: 1.1.4
|
|
|
|
:param size: The font size of Aileron Regular.
|
|
|
|
.. versionadded:: 10.1.0
|
|
|
|
:return: A font object.
|
|
"""
|
|
if isinstance(core, ModuleType) or size is not None:
|
|
return truetype(
|
|
BytesIO(
|
|
base64.b64decode(
|
|
b"""
|
|
[AWS-SECRET-REMOVED]RUYAqADnAAAo8AAAACRHUE9ThhmITwAAKfgAA
|
|
[AWS-SECRET-REMOVED]AAAAGBjbWFw5lFQMQAAA6gAAAGqZ2FzcP//AA
|
|
[AWS-SECRET-REMOVED]8ayQAAAPwAAAA2aGhlYQboArEAAAE0AAAAJGh
|
|
[AWS-SECRET-REMOVED]qbWF4cAC7AEYAAAFYAAAAIG5hbWUr+h5lAAAk
|
|
[AWS-SECRET-REMOVED]DqIhXw889QALA+gAAAAA0Bqf2QAAAADhCh2h/
|
|
[AWS-SECRET-REMOVED]7j/av9qA7EAAQAAAAAAAAAAAAAAAAAAAHQAAQ
|
|
[AWS-SECRET-REMOVED]ADAfoBkAAFAAgCigJYAAAASwKKAlgAAAFeADI
|
|
[AWS-SECRET-REMOVED]VS1dOAEAAIPsCAwL/GgDIA8oA5iAAAJMAAAAA
|
|
[AWS-SECRET-REMOVED]AVMAVgJEAEYCRAA1AuQAKQKOAEAAsAArATsAZ
|
|
[AWS-SECRET-REMOVED]AApAkQAggJEADwCRAAtAkQAIQJEADkCRAArAk
|
|
[AWS-SECRET-REMOVED]QB8wAjA1QANgJ/AB0CcwBkArsALwLFAGQCSwB
|
|
[AWS-SECRET-REMOVED]iAGQCzgBkAuEALwJWAGQC3QAvAmsAZAJJADQC
|
|
[AWS-SECRET-REMOVED]YgEv//sBJwAiAkQAUAH0ADIBLAApAhMAJAJjA
|
|
[AWS-SECRET-REMOVED]On/8wIKAEoA9wBGA1cASgJRAEoCSgAeAmMASg
|
|
[AWS-SECRET-REMOVED]/6AgEAAQHOABQBLwBAAPoAYAEvACECRABNA0Y
|
|
[AWS-SECRET-REMOVED]A9wAWAaEANgGhABYCbAAlAYMAeAGDADkA6/9q
|
|
[AWS-SECRET-REMOVED]AKQAAwABAAAAHAAEAIgAAAAeABAAAwAOAH4Aq
|
|
[AWS-SECRET-REMOVED]ACpAKsAsAC0ALcAuyAYIBwgJiA5IEQhIvsB//
|
|
[AWS-SECRET-REMOVED]EAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
|
|
[AWS-SECRET-REMOVED]AAAAAAAAAAAEAAAMEBQYHCAkKCwwNDg8QERIT
|
|
[AWS-SECRET-REMOVED]MjM0NTY3ODk6Ozw9Pj9AQUJDREVGR0hJSktMT
|
|
[AWS-SECRET-REMOVED]AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGQAAA
|
|
[AWS-SECRET-REMOVED]AAAAAAY2htAAAAAAAAAABrbGlqAAAAAHAAbm9
|
|
[AWS-SECRET-REMOVED]AAAAAAAAAAAAmACYAJgAmAD4AUgCCAMoBCgFO
|
|
[AWS-SECRET-REMOVED]Aw4DIgNkA5wDugPUA+gD/AQQBEYEogS8BPoFJ
|
|
[AWS-SECRET-REMOVED]gdUB2YHkAeiB8AH3AfyCAoIHAgqCDoITghcCG
|
|
[AWS-SECRET-REMOVED]wLDAs8C1YLjAuyC9oL7gwMDCYMSAxgDKAMrAz
|
|
[AWS-SECRET-REMOVED]sDnoOnA7EDvwAAAAFAAAAAAH0ArwAAwAGAAkA
|
|
[AWS-SECRET-REMOVED]jgFUqsiqArz9RAGLAP/+1P8B/v3VAP8BLP4CA
|
|
[AWS-SECRET-REMOVED]E4MZk84JCQ4JLQB/v3AJDgkJDgAAgBWAeUBPA
|
|
[AWS-SECRET-REMOVED]AAAAIARgAAAf4CsgAbAB8AAAEHMxUjByM3Iwc
|
|
[AWS-SECRET-REMOVED]bLzovWmYdZXEvOi9bLzovWp9bHlsBn4w429vb
|
|
[AWS-SECRET-REMOVED]JRQGBxUjNS4BJzMeARcRLgE0Njc1MxUeARcjJ
|
|
[AWS-SECRET-REMOVED]l9oVTpVYwpcC1ttXP6cLTQuM5szOrVRZwlOTQ
|
|
[AWS-SECRET-REMOVED]j+8/YGOjReAAAAAAUAKf/yArsCvAAHAAsAFQA
|
|
[AWS-SECRET-REMOVED]UBiImNDYiBhUUFjI2NTR5iFBQiFCVVwHAV/5c
|
|
[AWS-SECRET-REMOVED]MC80NC8w/uNWklZWkhozMC80NC8wAAAAAgBA/
|
|
[AWS-SECRET-REMOVED]hcVJiMiBhUUFhcWOwE1MxUFFBYzMjc1IyIHDg
|
|
[AWS-SECRET-REMOVED]ksPCkUUk0BgUb+zBVUZ0BkDw5RO1huCkULQzp
|
|
[AWS-SECRET-REMOVED]TIycze0YKWgHl+gAAAAABAGT/sAEXAwwACQAA
|
|
[AWS-SECRET-REMOVED]AAEAHv+wANEDDAAJAAATMx4BFAYHIzYQHjo5Q
|
|
[AWS-SECRET-REMOVED]AE3FwcXBycHJzcnNxcnMwEtmxOfcTJjYzJxnx
|
|
[AWS-SECRET-REMOVED]sAAAEjFSM1IzUzNTMVMwH0tTq1tTq1AR/Kyjj
|
|
[AWS-SECRET-REMOVED]S3AAAAQAgAP8A8gE3AAMAABMjNTPy0tIA/zgA
|
|
[AWS-SECRET-REMOVED]JCQ4AAAAAf/7/+IBNALQAAMAABcjEzM5Pvs+H
|
|
[AWS-SECRET-REMOVED]QHy/g5gATL+zgLA/TJEAkYAAAAAAQCCAAABlg
|
|
[AWS-SECRET-REMOVED]sWAAEAPAAAAg4CwAAZAAA3IRUhNRM+ATU0JiM
|
|
[AWS-SECRET-REMOVED]8aGVtSl5GRjEA/0RVLzlLmAoKa3FsUkNxXQAA
|
|
[AWS-SECRET-REMOVED]NjU0KwE1MzI2NTQmIyIGDwEjNz4BMzIWFRQGA
|
|
[AWS-SECRET-REMOVED]GhfcEMBbxJbQl1x0AoKRkZHPn9GSD80QUVCCg
|
|
[AWS-SECRET-REMOVED]E1ATMRMyMRBg8BAiRXVv6qAVZWV60dHLCurq4
|
|
[AWS-SECRET-REMOVED]GIyIvATMXFjMyNjU0JiMiByMTIRUhBzc2ATNv
|
|
[AWS-SECRET-REMOVED]gcUKCoFXTU5bYgGRRvAuHQAAAAACACv/8gITA
|
|
[AWS-SECRET-REMOVED]zYTMjY1NCYjIgYVFBYBLmp7imr0l3RZdAgBXA
|
|
[AWS-SECRET-REMOVED]7sPiz+ZF1LTmJbU0lhAAAAAQAyAAACGgKyAAY
|
|
[AWS-SECRET-REMOVED]ALP/xAhgCwAAWACAALAAAAR4BFRQGIyImNTQ2
|
|
[AWS-SECRET-REMOVED]FRQWAZQ5S5BmbIpPOjA7ecp5P2F8Q0J8RIVJS
|
|
[AWS-SECRET-REMOVED]0RENzT9/ko+Ok1NOj1LAAIAMf/yAhkCwAAXAC
|
|
[AWS-SECRET-REMOVED]U0JiMiBhUUFgEl9Jd0WXQIAVwCGGecCic1SWp
|
|
[AWS-SECRET-REMOVED]kW1NJYV1LTmIAAAACACX/8gClAiAABwAPAAAS
|
|
[AWS-SECRET-REMOVED]OCQkOP52JDgkJDgAAAAC/+H/iAClAiAABwAMA
|
|
[AWS-SECRET-REMOVED]CQ4/mba5gAAAQBnAB4B+AH0AAYAAAENARUlNS
|
|
[AWS-SECRET-REMOVED]ADAAcAAAEhNSERITUhAfT+XAGk/lwBpAGDOP8
|
|
[AWS-SECRET-REMOVED]qAStEyUSmpkYAAAAAAgAj//IB1ALAABgAIAAA
|
|
[AWS-SECRET-REMOVED]IiY0AQRibmktIAJWBSEqNig+NTlHBFoDezQ4J
|
|
[AWS-SECRET-REMOVED]DgAAAAAAgA2/5gDFgKYADYAQgAAAQMGFRQzMj
|
|
[AWS-SECRET-REMOVED]MiJwcGIyImNTQ2MzIfATcHNzYmIyIGFRQzMjY
|
|
[AWS-SECRET-REMOVED]RWQsVLjY5VHtdPBwJETcJDyUoOkZEJz8B0f74
|
|
[AWS-SECRET-REMOVED]TVRmmR8wPdYnQzxuSWVGAAIAHQAAAncCsgAHA
|
|
[AWS-SECRET-REMOVED]rL9TgE6ATQAAAADAGQAAAJMArIAEAAbACcAAA
|
|
[AWS-SECRET-REMOVED]E1NCcmKwEVMzIBvkdHZkwiNt7LOSGq/oeFHBt
|
|
[AWS-SECRET-REMOVED]ED2NfDAL93AU+N24PBP0AAAAAAQAv//ICjwLA
|
|
[AWS-SECRET-REMOVED]NDYBdX+PCwFWAiKiaHx5ZaIiAlYBCpWBk6a0A
|
|
[AWS-SECRET-REMOVED]gAMABkAAAEeARUUBgcGKwERMzITPgE1NCYnJi
|
|
[AWS-SECRET-REMOVED]WUug8EArL9mQ+PeHGHDgX92gAAAAABAGQAAAI
|
|
[AWS-SECRET-REMOVED]zRkYCskbwRvAAAAABAGQAAAIlArIACQAAExUh
|
|
[AWS-SECRET-REMOVED]L//yAo8CwAAfAAABMxEjNQcGIyImNTQ2MzIWH
|
|
[AWS-SECRET-REMOVED]VYCIqJofHllVG+hAU3+s3hARsicn8uAagoKpq
|
|
[AWS-SECRET-REMOVED]MRIRECjFb+hFZWAXwCsv1OAS7+0gKy/sQBPAA
|
|
[AWS-SECRET-REMOVED]/8gHoArIAEwAAAREUBw4BIyImLwEzFxYzMjc2
|
|
[AWS-SECRET-REMOVED]KYyEFD0BpwAAAAABAGQAAAJ0ArIACwAACQEjA
|
|
[AWS-SECRET-REMOVED]v6RAW8AAQBkAAACLwKyAAUAACUVIREzEQIv/j
|
|
[AWS-SECRET-REMOVED]cDIwMmJxYVESMRMxsBAxRWAiMxemx8NxsCVo7
|
|
[AWS-SECRET-REMOVED]AAAEAZAAAAoACsgANAAAhIwEWFREjETMBJjUR
|
|
[AWS-SECRET-REMOVED]AgAv//ICuwLAAAkAEwAAEiAWFRQGICY1NBIyN
|
|
[AWS-SECRET-REMOVED]v47nIeIm5uIhwACAGQAAAJHArIADgAYAAABHg
|
|
[AWS-SECRET-REMOVED]uAVtY7GlxcGDWIiDUCrgtnVlVpCgT+5gKy/rU
|
|
[AWS-SECRET-REMOVED]iBwYjIiY1NDYgFhUUJRQWMjY1NCYiBgI9PUMx
|
|
[AWS-SECRET-REMOVED]xcWitbWHnJyHiJubAAIAZAAAAlgCsgAXACMAA
|
|
[AWS-SECRET-REMOVED]TU0JyYrAQIqDCJfGQwNWhAhglbiOx9QXEY1Tv
|
|
[AWS-SECRET-REMOVED]RAAgVAOGoQBAABADT/8gIoAsAAJQAAATIWFyM
|
|
[AWS-SECRET-REMOVED]1NDYBOmd2ClwGS0E6SUNRdW+HZnKKC1wPWkQ9
|
|
[AWS-SECRET-REMOVED]FRdYUFdrAAAAAAEAIgAAAmQCsgAHAAABIxEjE
|
|
[AWS-SECRET-REMOVED]AABERQHDgEiJicmNREzERQXHgEyNjc2NRECZA
|
|
[AWS-SECRET-REMOVED]UrEkRQUEQSKwGrAAAAAAEAIAAAAnoCsgAGAAA
|
|
[AWS-SECRET-REMOVED]CsgAMAAABAyMLASMDMxsBMxsBA7HAcZyicrZi
|
|
[AWS-SECRET-REMOVED]Am8CsgALAAAhCwEjEwMzGwEzAxMCCsrEY/bkY
|
|
[AWS-SECRET-REMOVED]QKyAAgAAAERIxEDMxsBMwFdVvRjwLphARD+8A
|
|
[AWS-SECRET-REMOVED]EVAQI5/fUBof57Aen+YUZGQgIqRkX92QAAAAA
|
|
[AWS-SECRET-REMOVED]UOANcAAAB//v/4gE0AtAAAwAABSMDMwE0Pvs+
|
|
[AWS-SECRET-REMOVED]aaNQOALsOAABAFAA1wH0AmgABgAAJQsBIxMzE
|
|
[AWS-SECRET-REMOVED]AMAAAUhNSEBwv5wAZBWOAAAAAEAKQJEALYCsg
|
|
[AWS-SECRET-REMOVED]AlAAAhJwcGIyImNTQ2OwE1NCcmIyIHIz4BMzI
|
|
[AWS-SECRET-REMOVED]aBm1Zrg4DCuQ9R+5MOSFQR1tbDiwUUXBUXowf
|
|
[AWS-SECRET-REMOVED]ATIWFRQGIyImLwEVIxEzETc2EzI2NTQmIyIGH
|
|
[AWS-SECRET-REMOVED]5QTEDRJAt/+3jkq/hRuZV55ZWsdX14AAQAe//
|
|
[AWS-SECRET-REMOVED]Y1NDYBF152DFocbEJXU0A1Rw1aE3pbaoKQAiB
|
|
[AWS-SECRET-REMOVED]eAAABESM1BwYjIiY1NDYzMhYfAREDMjY9ATQm
|
|
[AWS-SECRET-REMOVED]/SFVOSqXeIuUExA0ARb9VWVrHV9ebmVeeQACA
|
|
[AWS-SECRET-REMOVED]TQ2MzIWJyIGByEmAf0C/oAGUkA1SwlaD4FXbI
|
|
[AWS-SECRET-REMOVED]0AAAEAFQAAARoC8gAWAAATBh0BMxUjESMRIzU
|
|
[AWS-SECRET-REMOVED]C/jQBzEIsJRs5PwVHEwAAAAIAHv8uAhkCIAAi
|
|
[AWS-SECRET-REMOVED]NTQ2MzIWHwE1AzI2PQE0JiMiBhUUFgIZAQSEd
|
|
[AWS-SECRET-REMOVED]FMCEv5wSh1zeq8KCTI8VU0ZIQk5Kpd4i5QTED
|
|
[AWS-SECRET-REMOVED]EjETQnLgEHDgEdASMRMxE3NjMyFgIIAlYCBDs
|
|
[AWS-SECRET-REMOVED]TPSxUAAACAD4AAACsAsAABwALAAASMhYUBiIm
|
|
[AWS-SECRET-REMOVED]LgCnAsAABwAVAAASMhYUBiImNBcRFAcGIyInN
|
|
[AWS-SECRET-REMOVED]CUbZAJGBzMOHgJEAAAAAQBKAAACCALfAAsAAC
|
|
[AWS-SECRET-REMOVED]v6/ugAAQBG//wA3gLfAA8AABMRFBceATcVBiM
|
|
[AWS-SECRET-REMOVED]SNAJKAAAAAQBKAAADEAIgACQAAAEWFREjETQn
|
|
[AWS-SECRET-REMOVED]CwVWBAxedFYEDF50VlYiJko7ThAvJkpEVAGfI
|
|
[AWS-SECRET-REMOVED]AAAAAEASgAAAgoCIAAWAAABFhURIxE0JyYjIg
|
|
[AWS-SECRET-REMOVED]tA/tYBJDEbbHR/6QISWz0sVAAAAAACAB7/8gI
|
|
[AWS-SECRET-REMOVED]Hh/8Ah7ieWlqeWgIgn/Cfn/D+s3ZfYHV1YF8A
|
|
[AWS-SECRET-REMOVED]FTc2EzI2NTQmIyIGHQEUFgFUcYCVbiNJEyNWV
|
|
[AWS-SECRET-REMOVED]V55ZWsdX14AAgAe/zwCGQIgABEAHgAAAREjEQ
|
|
[AWS-SECRET-REMOVED]gyWnGAlW4jSRMjp0leYUFJXFMCEv0qARk5Kpd
|
|
[AWS-SECRET-REMOVED]AAAEyFxUmBhURIxEzFTc2ARoWDkdXVlYwIwIe
|
|
[AWS-SECRET-REMOVED]IyYjIgYVFBYXHgEVFAYjIiYnMxYzMjY1NCYnL
|
|
[AWS-SECRET-REMOVED]llkAiBaS2MrJCUoEBlPQkhOVFZoKCUmLhIWSE
|
|
[AWS-SECRET-REMOVED]YnJjURIzUzNTMVMxWxAQMmMx8qMjMEAUdHVmM
|
|
[AWS-SECRET-REMOVED]CAhIAFwAAAREjNQcGIyImJyY1ETMRFBceATMy
|
|
[AWS-SECRET-REMOVED]OQE+/tIlJC43c4DpAAAAAAEAAQAAAfwCEgAGA
|
|
[AWS-SECRET-REMOVED]AEAAAMLAhIADAAAAQMjCwEjAzMbATMbAQMLqW
|
|
[AWS-SECRET-REMOVED]AB//oAAAHWAhIACwAAARMjJwcjEwMzFzczARq
|
|
[AWS-SECRET-REMOVED]B+wISABEAAAEDDgEjIic1FjMyNj8BAzMbAQH7
|
|
[AWS-SECRET-REMOVED]/i4B0gABABQAAAGxAg4ACQAAJRUhNQEhNSEVA
|
|
[AWS-SECRET-REMOVED]AEOAwwALAAAASMiBhUUFxYVFAYHHgEVFAcGFR
|
|
[AWS-SECRET-REMOVED]MLDS4pKS4NCyMqDAtERAwLUlILDERECwLUGBk
|
|
[AWS-SECRET-REMOVED]VGDsvAAAAAAEAYP84AJoDIAADAAAXIxEzmjo6
|
|
[AWS-SECRET-REMOVED]MzI2NTQnJjU0NjcuATU0NzY1NCYrATUzMhYVF
|
|
[AWS-SECRET-REMOVED]wF6OAhFIkxVGDsvOBgZFk5bICs1BQU3KyBbTh
|
|
[AWS-SECRET-REMOVED]ImJyYjIhUjNDMyFhcWMzIBvjhuGywtQR0xOG4
|
|
[AWS-SECRET-REMOVED]AEQApAAAAIBYQBiAmECQgBhUUFiA2NTQlMhYX
|
|
[AWS-SECRET-REMOVED]B/7wubkBELn+xVBnD1wSWDo+QTcqOQZcEmZWX
|
|
[AWS-SECRET-REMOVED]n5na34AAgB4AFIB9AGeAAUACwAAAQcXIyc3Mw
|
|
[AWS-SECRET-REMOVED]IAHAHSAQ4CwAAHAA8AABIyFhQGIiY0NiIGFBY
|
|
[AWS-SECRET-REMOVED]AAAIAUAAAAfQCCwALAA8AAAEzFSMVIzUjNTM1
|
|
[AWS-SECRET-REMOVED]AQB0AkQBAQKyAAMAABMjNzOsOD1QAkRuAAAAA
|
|
[AWS-SECRET-REMOVED]DooKDoAAAIAOQBSAbUBngAFAAsAACUHIzcnMw
|
|
[AWS-SECRET-REMOVED]ABADYB5QDhAt8ABAAAEzczByM2Xk1OXQHv8Po
|
|
[AWS-SECRET-REMOVED]ANgHlAYsC3wAEAAkAABM3MwcjPwEzByM2Xk1O
|
|
[AWS-SECRET-REMOVED]EwcjNzMXByM3M8FeTU5dql5NTl0C1fD6CvD6A
|
|
[AWS-SECRET-REMOVED]AYiJjQ2MhYUBiImNEk4JCQ4JOw4JCQ4JOw4JC
|
|
[AWS-SECRET-REMOVED]oBngAFAAABBxcjJzcBSomJSYmJAZ6mpqamAAA
|
|
[AWS-SECRET-REMOVED]mpgAAAf9qAAABgQKyAAMAACsBATM/VwHAVwKy
|
|
[AWS-SECRET-REMOVED]NwcjJxcjNTMXN9pKMkoByDICKzQqATJLKysCl
|
|
[AWS-SECRET-REMOVED]xEjESMRIzUzNTQ3NjMyFxUmBgcGHQEBvFbCVj
|
|
[AWS-SECRET-REMOVED]AVIRYAAAABABX//AHkAvIAJQAAJR4BNxUGIyI
|
|
[AWS-SECRET-REMOVED]BowIcIxkkKi4CAR4nXgwDbW1WLy8DEbNdOmYa
|
|
[AWS-SECRET-REMOVED]AAAAAAAWAQ4AAQAAAAAAAAATACgAAQAAAAAAA
|
|
QAHAEwAAQAAAAAAAgAHAGQAAQAAAAAAAwAa[AWS-ACCESS-KEY-REMOVED]AQAAAAAABQA8AU8AAQAAAA
|
|
[AWS-SECRET-REMOVED]gAAQAAAAAACwAXAjQAAQAAAAAADAAXAnwAAwA
|
|
[AWS-SECRET-REMOVED]OAFQAAwABBAkAAwA0AGwAAwABBAkABAAOAL0A
|
|
[AWS-SECRET-REMOVED]CAAWAbwAAwABBAkACQAWAeAAAwABBAkACwAuA
|
|
[AWS-SECRET-REMOVED]HMAIABSAGUAcwBlAHIAdgBlAGQALgAATm8gUm
|
|
[AWS-SECRET-REMOVED]AAQWlsZXJvbgAAUgBlAGcAdQBsAGEAcgAAUmV
|
|
[AWS-SECRET-REMOVED]AaQBsAGUAcgBvAG4ALQBSAGUAZwB1AGwAYQBy
|
|
[AWS-SECRET-REMOVED]QQBpAGwAZQByAG8AbgAAQWlsZXJvbgAAVgBlA
|
|
[AWS-SECRET-REMOVED]DAAMAAxAC4AMQAwADIAOwBoAG8AdABjAG8Abg
|
|
[AWS-SECRET-REMOVED]BmAC4AbABpAGIAMgAuADUALgA1ADgAMwAyADk
|
|
[AWS-SECRET-REMOVED]jb252IDEuMC43MDttYWtlb3RmLmxpYjIuNS41
|
|
[AWS-SECRET-REMOVED]bABhAHIAAEFpbGVyb24tUmVndWxhcgAAUwBvA
|
|
[AWS-SECRET-REMOVED]wAAUwBvAHIAYQAgAFMAYQBnAGEAbgBvAABTb3
|
|
[AWS-SECRET-REMOVED]AuAGQAbwB0AGMAbwBsAG8AbgAuAG4AZQB0AAB
|
|
[AWS-SECRET-REMOVED]AcAA6AC8ALwB3AHcAdwAuAGQAbwB0AGMAbwBs
|
|
[AWS-SECRET-REMOVED]bG9uLm5ldAAAAAACAAAAAAAA/4MAMgAAAAAAA
|
|
[AWS-SECRET-REMOVED]gAHAAgACQAKAAsADAANAA4ADwAQABEAEgATAB
|
|
[AWS-SECRET-REMOVED]MAJAAlACYAJwAoACkAKgArACwALQAuAC8AMAA
|
|
[AWS-SECRET-REMOVED]AAEEAQgBDAEQARQBGAEcASABJAEoASwBMAE0A
|
|
[AWS-SECRET-REMOVED]XQBeAF8AYABhAIsAqQCDAJMAjQDDAKoAtgC3A
|
|
[AWS-SECRET-REMOVED]AAADAAAABwAAAACAAIAAwBxAAEAcgBzAAIABA
|
|
[AWS-SECRET-REMOVED]AEAAAAAP//AAEAAAAWAANDQVQgAB5NT0wgABZ
|
|
[AWS-SECRET-REMOVED]ADmxvY2wAFAAAAAEAAQAAAAEAAAACAAYAEAAG
|
|
[AWS-SECRET-REMOVED]AAAAAQABAE8AAQABAGcAAQABAE8AAwAAAAIAE
|
|
[AWS-SECRET-REMOVED]gABAAgAAgAGAAwAcwACAE8AcgACAEwAAQABAE
|
|
[AWS-SECRET-REMOVED]AAAP//AAIAAAABABYAA0NBVCAAFk1PTCAAFlJ
|
|
[AWS-SECRET-REMOVED]AAAEAAAAAAAEAAQACAAYADgABAAAAAQASAAIA
|
|
[AWS-SECRET-REMOVED]EgAEAAAAAQAMAAEAOP/nAAEAAQAkAAIGigAEA
|
|
[AWS-SECRET-REMOVED]AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
|
|
[AWS-SECRET-REMOVED]AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
|
|
[AWS-SECRET-REMOVED]AAAAAAAAAAAAAAAAAAAAA/9T/6AAAAAD/8QAA
|
|
[AWS-SECRET-REMOVED]AAAAAAAAAAD/7gAAAAAAAAAAAAAAAAAA//MAA
|
|
[AWS-SECRET-REMOVED]AAAAAAAAAAAABIAAAAAAAAAAP/5AAAAAAAAAA
|
|
[AWS-SECRET-REMOVED]AAAAAAAAAAAP/gAAD/4AAAAAAAAAAAAAAAAAA
|
|
[AWS-SECRET-REMOVED]AAAAAAAAA//L/9AAAAAAAAAAAAAAAAAAAAAAA
|
|
[AWS-SECRET-REMOVED]AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
|
|
[AWS-SECRET-REMOVED]AAAAAAAAAAAAAAAAAAAAAAAAAAAAP/zAAAAAA
|
|
[AWS-SECRET-REMOVED]AAAAAAAAAAAAAAAP/mAAAAAAAAAAAAAAAAAAD
|
|
[AWS-SECRET-REMOVED]AAAAAAAD/+AAAAAAAAP/OAAAAAAAAAAAAAAAA
|
|
[AWS-SECRET-REMOVED]AAAAAP/0AAAACAAAAAAAAAAAAAAAAAAAAAAAA
|
|
[AWS-SECRET-REMOVED]P/ZAAD/egAA/1kAAAAA/5D/rgAAAAAAAAAAAA
|
|
[AWS-SECRET-REMOVED]AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
|
|
[AWS-SECRET-REMOVED]E/98AAAAA/8P/+P/0//oAAAAAAAAAAAAA//gA
|
|
[AWS-SECRET-REMOVED]AAAAAAAAAAAAAAAAAAAA/+AAAAAAAAAAAAAAA
|
|
[AWS-SECRET-REMOVED]AAAAAAAAAD/w//C/9MAAP/SAAD/9wAAAAAAAA
|
|
[AWS-SECRET-REMOVED]AA//QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
|
|
[AWS-SECRET-REMOVED]//QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
|
|
[AWS-SECRET-REMOVED]AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
|
|
[AWS-SECRET-REMOVED]AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
|
|
[AWS-SECRET-REMOVED]AAAAAAAAAAAAAAAAAAAAAAAAD/6AAAAAAAAAA
|
|
[AWS-SECRET-REMOVED]AAAAAAAAAAAAAAQAkAFAAEAAAAAQACwAAABcA
|
|
[AWS-SECRET-REMOVED]AwANAAAAAQAJAAAAAAAAAAAAAAAAAAAAGAAAA
|
|
[AWS-SECRET-REMOVED]AAACgAAAAwAAgAPABEAFgAAAAAAAAAAAAAAAA
|
|
[AWS-SECRET-REMOVED]AFAAEAEQBdAAYAAAAAAAAAAAAAAAAAAAAAAAA
|
|
[AWS-SECRET-REMOVED]ABwAAAAAACAAAAAAAAAAAAAcAAAAHAAAAEwAJ
|
|
[AWS-SECRET-REMOVED]AAIAAgAAAAIAGAAXAAAAGAAAABYAFgACABYAA
|
|
[AWS-SECRET-REMOVED]AAAAAAAAAAAAAAAAAASAAAAEgAGAAEAHgAkAC
|
|
[AWS-SECRET-REMOVED]UASABOAE8AUgBTAFUAVwBZAFoAWwBcAF0AcwA
|
|
[AWS-SECRET-REMOVED]=
|
|
"""
|
|
)
|
|
),
|
|
10 if size is None else size,
|
|
layout_engine=Layout.BASIC,
|
|
)
|
|
return load_default_imagefont()
|