修正

main.py

@@ -2,36 +2,35 @@ from PIL import Image, ImageDraw, ImageFont, ImageEnhance
 from pilmoji import Pilmoji
 import textwrap
 
-BASE_GRADATION_IMAGE = Image.open('base-gd.png')
-BASE_WHITE_IMAGE = Image.open('base.png')
+BASE_GRADATION_IMAGE = Image.open("images/base-gd.png")
+BASE_WHITE_IMAGE = Image.open("images/base.png")
 
 ICON = 'icon.png'
 
-MPLUS_FONT_16 = ImageFont.truetype('fonts/MPLUSRounded1c-Regular.ttf', size=16)
+MPLUS_FONT_16 = ImageFont.truetype("fonts/MPLUSRounded1c-Regular.ttf", size=16)
 
-def draw_text(im, ofs, string, font='fonts/MPLUSRounded1c-Regular.ttf', size=16, color=(0,0,0,255), split_len=None, padding=4, auto_expand=False, emojis: list = [], disable_dot_wrap=False):
+def draw_text(im, ofs, string, font="fonts/MPLUSRounded1c-Regular.ttf", size=16, color=(0,0,0,255), split_len=None, padding=4, auto_expand=False, emojis: list = [], disable_dot_wrap=False):
     
     draw = ImageDraw.Draw(im)
     fontObj = ImageFont.truetype(font, size=size)
 
-    # 改行、句読点(。、.,)で分割した後にさらにワードラップを行う
     pure_lines = []
     pos = 0
-    l = ''
+    l = ""
 
     if not disable_dot_wrap:
         for char in string:
-            if char == '\n':
+            if char == "\n":
                 pure_lines.append(l)
-                l = ''
+                l = ""
                 pos += 1
-            elif char == '、' or char == ',':
-                pure_lines.append(l + ('、' if char == '、' else ','))
-                l = ''
+            elif char == "、" or char == ",":
+                pure_lines.append(l + ("、" if char == "、" else ","))
+                l = ""
                 pos += 1
-            elif char == '。' or char == '.':
-                pure_lines.append(l + ('。' if char == '。' else '.'))
-                l = ''
+            elif char == "。" or char == ".":
+                pure_lines.append(l + ("。" if char == "。" else "."))
+                l = ""
                 pos += 1
             else:
                 l += char
@@ -40,7 +39,7 @@ def draw_text(im, ofs, string, font='fonts/MPLUSRounded1c-Regular.ttf', size=16,
         if l:
             pure_lines.append(l)
     else:
-        pure_lines = string.split('\n')
+        pure_lines = string.split("\n")
 
     lines = []
 
@@ -74,13 +73,13 @@ def draw_text(im, ofs, string, font='fonts/MPLUSRounded1c-Regular.ttf', size=16,
 
     return (0, dy, real_y)
 
-content = "これってなんですかね？知らないんですけどwwww でも結局はあれだよね"
+content = "こっっっっっっっっっっbれってなんですかね？知らないんですけどwwww でも結局はあれだよね"
 # 引用する
 img = BASE_WHITE_IMAGE.copy()
 
 icon = Image.open(ICON)
 icon = icon.resize((720, 720), Image.ANTIALIAS)
-icon = icon.convert('L')
+icon = icon.convert("L")
 icon_filtered = ImageEnhance.Brightness(icon)
 
 img.paste(icon_filtered.enhance(0.7), (0,0))
@@ -104,9 +103,9 @@ tsize_name = draw_text(img, (base_x, name_y), uname, size=25, color=(255,255,255
 # ID描画
 id = '000000000000'
 id_y = name_y + tsize_name[1] + 4
-tsize_id = draw_text(img, (base_x, id_y), f'({id})', size=18, color=(180,180,180,255), split_len=45, disable_dot_wrap=True)
+tsize_id = draw_text(img, (base_x, id_y), f"({id})", size=18, color=(180,180,180,255), split_len=45, disable_dot_wrap=True)
 
 # クレジット
-tx.text((1125, 694), 'TakasumiBOT#7189', font=MPLUS_FONT_16, fill=(120,120,120,255))
+tx.text((1125, 694), "TakasumiBOT#7189", font=MPLUS_FONT_16, fill=(120,120,120,255))
 
-img.save('quote.png', quality=95)
+img.save("quote.png", quality=95)

pilmoji/__init__.py

@@ -1,6 +0,0 @@
-from . import helpers, source
-from .core import Pilmoji
-from .helpers import *
-
-__version__ = '2.0.1-CBT-1'
-__author__ = 'jay3332'

pilmoji/core.py

@@ -1,352 +0,0 @@
-from __future__ import annotations
-
-import math
-from optparse import Option
-
-from PIL import Image, ImageDraw, ImageFont, UnidentifiedImageError
-from typing import Dict, Optional, SupportsInt, TYPE_CHECKING, Tuple, Type, TypeVar, Union
-
-from .helpers import NodeType, getsize, to_nodes
-from .source import BaseSource, HTTPBasedSource, Twemoji, _has_requests
-
-if TYPE_CHECKING:
-    from io import BytesIO
-
-    FontT = Union[ImageFont.ImageFont, ImageFont.FreeTypeFont, ImageFont.TransposedFont]
-    ColorT = Union[int, Tuple[int, int, int], Tuple[int, int, int, int], str]
-
-
-P = TypeVar('P', bound='Pilmoji')
-
-__all__ = (
-    'Pilmoji',
-)
-
-
-class Pilmoji:
-    """The main emoji rendering interface.
-
-    .. note::
-        This should be used in a context manager.
-
-    Parameters
-    ----------
-    image: :class:`PIL.Image.Image`
-        The Pillow image to render on.
-    source: Union[:class:`~.BaseSource`, Type[:class:`~.BaseSource`]]
-        The emoji image source to use.
-        This defaults to :class:`~.TwitterEmojiSource`.
-    cache: bool
-        Whether or not to cache emojis given from source.
-        Enabling this is recommended and by default.
-    draw: :class:`PIL.ImageDraw.ImageDraw`
-        The drawing instance to use. If left unfilled,
-        a new drawing instance will be created.
-    render_discord_emoji: bool
-        Whether or not to render Discord emoji. Defaults to `True`
-    emoji_scale_factor: float
-        The default rescaling factor for emojis. Defaults to `1`
-    emoji_position_offset: Tuple[int, int]
-        A 2-tuple representing the x and y offset for emojis when rendering,
-        respectively. Defaults to `(0, 0)`
-    """
-
-    def __init__(
-        self,
-        image: Image.Image,
-        *,
-        source: Union[BaseSource, Type[BaseSource]] = Twemoji,
-        cache: bool = True,
-        draw: Optional[ImageDraw.ImageDraw] = None,
-        render_discord_emoji: bool = True,
-        emoji_scale_factor: float = 1.0,
-        emoji_position_offset: Tuple[int, int] = (0, 0)
-    ) -> None:
-        self.image: Image.Image = image
-        self.draw: ImageDraw.ImageDraw = draw
-
-        if isinstance(source, type):
-            if not issubclass(source, BaseSource):
-                raise TypeError(f'source must inherit from BaseSource, not {source}.')
-
-            source = source()
-
-        elif not isinstance(source, BaseSource):
-            raise TypeError(f'source must inherit from BaseSource, not {source.__class__}.')
-
-        self.source: BaseSource = source
-
-        self._cache: bool = bool(cache)
-        self._closed: bool = False
-        self._new_draw: bool = False
-
-        self._render_discord_emoji: bool = bool(render_discord_emoji)
-        self._default_emoji_scale_factor: float = emoji_scale_factor
-        self._default_emoji_position_offset: Tuple[int, int] = emoji_position_offset
-
-        self._emoji_cache: Dict[str, BytesIO] = {}
-        self._fedi_emoji_cache: Dict[str, BytesIO] = {}
-        self._discord_emoji_cache: Dict[int, BytesIO] = {}
-
-        self._create_draw()
-
-    def open(self) -> None:
-        """Re-opens this renderer if it has been closed.
-        This should rarely be called.
-
-        Raises
-        ------
-        ValueError
-            The renderer is already open.
-        """
-        if not self._closed:
-            raise ValueError('Renderer is already open.')
-
-        if _has_requests and isinstance(self.source, HTTPBasedSource):
-            from requests import Session
-            self.source._requests_session = Session()
-
-        self._create_draw()
-        self._closed = False
-
-    def close(self) -> None:
-        """Safely closes this renderer.
-
-        .. note::
-            If you are using a context manager, this should not be called.
-
-        Raises
-        ------
-        ValueError
-            The renderer has already been closed.
-        """
-        if self._closed:
-            raise ValueError('Renderer has already been closed.')
-
-        if self._new_draw:
-            del self.draw
-            self.draw = None
-
-        if _has_requests and isinstance(self.source, HTTPBasedSource):
-            self.source._requests_session.close()
-
-        if self._cache:
-            for stream in self._emoji_cache.values():
-                stream.close()
-
-            for stream in self._discord_emoji_cache.values():
-                stream.close()
-
-            self._emoji_cache = {}
-            self._discord_emoji_cache = {}
-
-        self._closed = True
-
-    def _create_draw(self) -> None:
-        if self.draw is None:
-            self._new_draw = True
-            self.draw = ImageDraw.Draw(self.image)
-
-    def _get_emoji(self, emoji: str, /) -> Optional[BytesIO]:
-        if self._cache and emoji in self._emoji_cache:
-            entry = self._emoji_cache[emoji]
-            entry.seek(0)
-            return entry
-
-        if stream := self.source.get_emoji(emoji):
-            if self._cache:
-                self._emoji_cache[emoji] = stream
-
-            stream.seek(0)
-            return stream
-
-    def _get_discord_emoji(self, id: SupportsInt, /) -> Optional[BytesIO]:
-        id = int(id)
-
-        if self._cache and id in self._discord_emoji_cache:
-            entry = self._discord_emoji_cache[id]
-            entry.seek(0)
-            return entry
-
-        if stream := self.source.get_discord_emoji(id):
-            if self._cache:
-                self._discord_emoji_cache[id] = stream
-
-            stream.seek(0)
-            return stream
-
-    def _get_fedi_emoji(self, url: str, /) -> Optional[BytesIO]:
-
-        if self._cache and url in self._fedi_emoji_cache:
-            entry = self._fedi_emoji_cache[url]
-            entry.seek(0)
-            return entry
-
-        if stream := self.source.get_fedi_emoji(url):
-            if self._cache:
-                self._fedi_emoji_cache[url] = stream
-
-            stream.seek(0)
-            return stream
-
-    def getsize(
-        self,
-        text: str,
-        font: FontT = None,
-        *,
-        spacing: int = 4,
-        emoji_scale_factor: float = None
-    ) -> Tuple[int, int]:
-        """Return the width and height of the text when rendered.
-        This method supports multiline text.
-
-        Parameters
-        ----------
-        text: str
-            The text to use.
-        font
-            The font of the text.
-        spacing: int
-            The spacing between lines, in pixels.
-            Defaults to `4`.
-        emoji_scalee_factor: float
-            The rescaling factor for emojis.
-            Defaults to the factor given in the class constructor, or `1`.
-        """
-        if emoji_scale_factor is None:
-            emoji_scale_factor = self._default_emoji_scale_factor
-
-        return getsize(text, font, spacing=spacing, emoji_scale_factor=emoji_scale_factor)
-
-    def text(
-        self,
-        xy: Tuple[int, int],
-        text: str,
-        fill: ColorT = None,
-        font: FontT = None,
-        anchor: str = None,
-        spacing: int = 4,
-        align: str = "left",
-        direction: str = None,
-        features: str = None,
-        language: str = None,
-        stroke_width: int = 0,
-        stroke_fill: ColorT = None,
-        embedded_color: bool = False,
-        *args,
-        emojis: list = None,
-        emoji_scale_factor: float = None,
-        emoji_position_offset: Tuple[int, int] = None,
-        **kwargs
-    ) -> None:
-        """Draws the string at the given position, with emoji rendering support.
-        This method supports multiline text.
-
-        .. note::
-            Some parameters have not been implemented yet.
-
-        .. note::
-            The signature of this function is a superset of the signature of Pillow's `ImageDraw.text`.
-
-        .. note::
-            Not all parameters are listed here.
-
-        Parameters
-        ----------
-        xy: Tuple[int, int]
-            The position to render the text at.
-        text: str
-            The text to render.
-        fill
-            The fill color of the text.
-        font
-            The font to render the text with.
-        spacing: int
-            How many pixels there should be between lines. Defaults to `4`
-        emoji_scale_factor: float
-            The rescaling factor for emojis. This can be used for fine adjustments.
-            Defaults to the factor given in the class constructor, or `1`.
-        emoji_position_offset: Tuple[int, int]
-            The emoji position offset for emojis. The can be used for fine adjustments.
-            Defaults to the offset given in the class constructor, or `(0, 0)`.
-        """
-
-        if emoji_scale_factor is None:
-            emoji_scale_factor = self._default_emoji_scale_factor
-
-        if emoji_position_offset is None:
-            emoji_position_offset = self._default_emoji_position_offset
-
-        if font is None:
-            font = ImageFont.load_default()
-
-        args = (
-            fill,
-            font,
-            anchor,
-            spacing,
-            align,
-            direction,
-            features,
-            language,
-            stroke_width,
-            stroke_fill,
-            embedded_color,
-            *args
-        )
-
-        x, y = xy
-        original_x = x
-        nodes = to_nodes(text, emojis=emojis)
-
-        for line in nodes:
-            x = original_x
-
-            for node in line:
-                content = node.content
-                width, height = font.getsize(content)
-
-                if node.type is NodeType.text:
-                    self.draw.text((x, y), content, *args, **kwargs)
-                    x += width
-                    continue
-
-                stream = None
-                if node.type is NodeType.emoji:
-                    stream = self._get_emoji(content)
-
-                elif self._render_discord_emoji and node.type is NodeType.discord_emoji:
-                    stream = self._get_discord_emoji(content)
-
-                elif node.type is NodeType.fedi_emoji:
-                    stream = self._get_fedi_emoji(content)
-
-                if not stream:
-                    self.draw.text((x, y), content, *args, **kwargs)
-                    x += width
-                    continue
-                
-                try:
-                    with Image.open(stream).convert('RGBA') as asset:
-                        width = int(emoji_scale_factor * font.size)
-                        size = width, math.ceil(asset.height / asset.width * width)
-                        asset = asset.resize(size, Image.ANTIALIAS)
-
-                        ox, oy = emoji_position_offset
-                        self.image.paste(asset, (x + ox, y + oy), asset)
-                except UnidentifiedImageError:
-                    self.draw.text((x, y), content, *args, **kwargs)
-                    x += width
-                    continue
-
-                x += width
-            y += spacing + font.size
-
-    def __enter__(self: P) -> P:
-        return self
-
-    def __exit__(self, *_) -> None:
-        self.close()
-
-    def __repr__(self) -> str:
-        return f'<Pilmoji source={self.source} cache={self._cache}>'

pilmoji/helpers.py

@@ -1,171 +0,0 @@
-from __future__ import annotations
-
-import re
-
-from enum import Enum
-
-from emoji import unicode_codes
-from PIL import ImageFont
-
-from typing import Dict, Final, List, NamedTuple, TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from .core import FontT
-
-# This is actually way faster than it seems
-language_pack: Dict[str, str] = unicode_codes.get_emoji_unicode_dict('en')
-_UNICODE_EMOJI_REGEX = '|'.join(map(re.escape, sorted(language_pack.values(), key=len, reverse=True)))
-_DISCORD_EMOJI_REGEX = '<a?:[a-zA-Z0-9_]{2,32}:[0-9]{17,22}>'
-_FEDI_EMOJI_REGEX = ':[a-zA-Z0-9_]+:'
-
-EMOJI_REGEX: Final[re.Pattern[str]] = re.compile(f'({_UNICODE_EMOJI_REGEX}|{_DISCORD_EMOJI_REGEX}|{_FEDI_EMOJI_REGEX})')
-
-__all__ = (
-    'EMOJI_REGEX',
-    'Node',
-    'NodeType',
-    'to_nodes',
-    'getsize'
-)
-
-
-class NodeType(Enum):
-    """|enum|
-
-    Represents the type of a :class:`~.Node`.
-
-    Attributes
-    ----------
-    text
-        This node is a raw text node.
-    emoji
-        This node is a unicode emoji.
-    discord_emoji
-        This node is a Discord emoji.
-    fedi_emoji
-        This node is a Fediverse emoji.
-    """
-
-    text          = 0
-    emoji         = 1
-    discord_emoji = 2
-    fedi_emoji    = 3
-
-
-class Node(NamedTuple):
-    """Represents a parsed node inside of a string.
-
-    Attributes
-    ----------
-    type: :class:`~.NodeType`
-        The type of this node.
-    content: str
-        The contents of this node.
-    """
-
-    type: NodeType
-    content: str
-
-    def __repr__(self) -> str:
-        return f'<Node type={self.type.name!r} content={self.content!r}>'
-
-
-def _parse_line(line: str, /, emojis: list = []) -> List[Node]:
-    nodes = []
-
-    for i, chunk in enumerate(EMOJI_REGEX.split(line)):
-        if not chunk:
-            continue
-
-        if not i % 2:
-            nodes.append(Node(NodeType.text, chunk))
-            continue
-        # fedi emojiであるかどうかチェックする
-        if chunk.startswith(':') and chunk.endswith(':'):
-            emoji_name = chunk.replace(':', '')
-            for e in emojis:
-                if e['name'] == emoji_name:
-                    # 存在するならノード変換
-                    node = Node(NodeType.fedi_emoji, e['url'])
-                    break
-            else:
-                # 存在しない場合テキスト扱い
-                node = Node(NodeType.text, chunk)
-        elif len(chunk) > 18:  # This is guaranteed to be a Discord emoji
-            node = Node(NodeType.discord_emoji, chunk.split(':')[-1][:-1])
-        else:
-            node = Node(NodeType.emoji, chunk)
-
-        nodes.append(node)
-
-    return nodes
-
-
-def to_nodes(text: str, /, emojis: list = []) -> List[List[Node]]:
-    """Parses a string of text into :class:`~.Node`s.
-
-    This method will return a nested list, each element of the list
-    being a list of :class:`~.Node`s and representing a line in the string.
-
-    The string ``'Hello\nworld'`` would return something similar to
-    ``[[Node('Hello')], [Node('world')]]``.
-
-    Parameters
-    ----------
-    text: str
-        The text to parse into nodes.
-
-    Returns
-    -------
-    List[List[:class:`~.Node`]]
-    """
-    return [_parse_line(line, emojis=emojis) for line in text.splitlines()]
-
-
-def getsize(
-    text: str,
-    font: FontT = None,
-    *,
-    spacing: int = 4,
-    emoji_scale_factor: float = 1
-) -> Tuple[int, int]:
-    """Return the width and height of the text when rendered.
-    This method supports multiline text.
-
-    Parameters
-    ----------
-    text: str
-        The text to use.
-    font
-        The font of the text.
-    spacing: int
-        The spacing between lines, in pixels.
-        Defaults to `4`.
-    emoji_scale_factor: float
-        The rescaling factor for emojis.
-        Defaults to `1`.
-    """
-    if font is None:
-        font = ImageFont.load_default()
-
-    x, y = 0, 0
-    nodes = to_nodes(text)
-
-    for line in nodes:
-        this_x = 0
-        for node in line:
-            content = node.content
-
-            if node.type is not NodeType.text:
-                width = int(emoji_scale_factor * font.size)
-            else:
-                width, _ = font.getsize(content)
-
-            this_x += width
-
-        y += spacing + font.size
-
-        if this_x > x:
-            x = this_x
-
-    return x, y - spacing

pilmoji/source.py

@@ -1,253 +0,0 @@
-from abc import ABC, abstractmethod
-from io import BytesIO
-
-from urllib.request import Request, urlopen
-from urllib.error import HTTPError
-from urllib.parse import quote_plus
-
-from typing import Any, ClassVar, Dict, Optional
-
-try:
-    import requests
-    _has_requests = True
-except ImportError:
-    requests = None
-    _has_requests = False
-
-__all__ = (
-    'BaseSource',
-    'HTTPBasedSource',
-    'DiscordEmojiSourceMixin',
-    'FediEmojiSource',
-    'EmojiCDNSource',
-    'TwitterEmojiSource',
-    'AppleEmojiSource',
-    'GoogleEmojiSource',
-    'MicrosoftEmojiSource',
-    'FacebookEmojiSource',
-    'MessengerEmojiSource',
-    'EmojidexEmojiSource',
-    'JoyPixelsEmojiSource',
-    'SamsungEmojiSource',
-    'WhatsAppEmojiSource',
-    'MozillaEmojiSource',
-    'OpenmojiEmojiSource',
-    'TwemojiEmojiSource',
-    'FacebookMessengerEmojiSource',
-    'Twemoji',
-    'Openmoji',
-)
-
-
-class BaseSource(ABC):
-    """The base class for an emoji image source."""
-
-    @abstractmethod
-    def get_emoji(self, emoji: str, /) -> Optional[BytesIO]:
-        """Retrieves a :class:`io.BytesIO` stream for the image of the given emoji.
-
-        Parameters
-        ----------
-        emoji: str
-            The emoji to retrieve.
-
-        Returns
-        -------
-        :class:`io.BytesIO`
-            A bytes stream of the emoji.
-        None
-            An image for the emoji could not be found.
-        """
-        raise NotImplementedError
-
-    @abstractmethod
-    def get_discord_emoji(self, id: int, /) -> Optional[BytesIO]:
-        """Retrieves a :class:`io.BytesIO` stream for the image of the given Discord emoji.
-
-        Parameters
-        ----------
-        id: int
-            The snowflake ID of the Discord emoji.
-
-        Returns
-        -------
-        :class:`io.BytesIO`
-            A bytes stream of the emoji.
-        None
-            An image for the emoji could not be found.
-        """
-        raise NotImplementedError
-
-    def __repr__(self) -> str:
-        return f'<{self.__class__.__name__}>'
-
-
-class HTTPBasedSource(BaseSource):
-    """Represents an HTTP-based source."""
-
-    REQUEST_KWARGS: ClassVar[Dict[str, Any]] = {
-        'headers': {'User-Agent': 'Mozilla/5.0'}
-    }
-
-    def __init__(self) -> None:
-        if _has_requests:
-            self._requests_session = requests.Session()
-
-    def request(self, url: str) -> bytes:
-        """Makes a GET request to the given URL.
-
-        If the `requests` library is installed, it will be used.
-        If it is not installed, :meth:`urllib.request.urlopen` will be used instead.
-
-        Parameters
-        ----------
-        url: str
-            The URL to request from.
-
-        Returns
-        -------
-        bytes
-
-        Raises
-        ------
-        Union[:class:`requests.HTTPError`, :class:`urllib.error.HTTPError`]
-            There was an error requesting from the URL.
-        """
-        if _has_requests:
-            with self._requests_session.get(url, **self.REQUEST_KWARGS) as response:
-                if response.ok:
-                    return response.content
-        else:
-            req = Request(url, **self.REQUEST_KWARGS)
-            with urlopen(req) as response:
-                return response.read()
-
-    @abstractmethod
-    def get_emoji(self, emoji: str, /) -> Optional[BytesIO]:
-        raise NotImplementedError
-
-    @abstractmethod
-    def get_discord_emoji(self, id: int, /) -> Optional[BytesIO]:
-        raise NotImplementedError
-
-class FediEmojiSourceMixin(HTTPBasedSource):
-
-    @abstractmethod
-    def get_emoji(self, emoji: str, /) -> Optional[BytesIO]:
-        raise NotImplementedError
-    
-    @abstractmethod
-    def get_discord_emoji(self, id: int, /) -> Optional[BytesIO]:
-        raise NotImplementedError
-    
-    def get_fedi_emoji(self, url: dict, /) -> Optional[BytesIO]:
-
-        _to_catch = HTTPError if not _has_requests else requests.HTTPError
-
-        try:
-            return BytesIO(self.request(url))
-        except _to_catch:
-            pass
-
-class DiscordEmojiSourceMixin(HTTPBasedSource):
-    """A mixin that adds Discord emoji functionality to another source."""
-
-    BASE_DISCORD_EMOJI_URL: ClassVar[str] = 'https://cdn.discordapp.com/emojis/'
-
-    @abstractmethod
-    def get_emoji(self, emoji: str, /) -> Optional[BytesIO]:
-        raise NotImplementedError
-
-    def get_discord_emoji(self, id: int, /) -> Optional[BytesIO]:
-        url = self.BASE_DISCORD_EMOJI_URL + str(id) + '.png'
-        _to_catch = HTTPError if not _has_requests else requests.HTTPError
-
-        try:
-            return BytesIO(self.request(url))
-        except _to_catch:
-            pass
-
-
-class EmojiCDNSource(DiscordEmojiSourceMixin, FediEmojiSourceMixin):
-    """A base source that fetches emojis from https://emojicdn.elk.sh/."""
-
-    BASE_EMOJI_CDN_URL: ClassVar[str] = 'https://emojicdn.elk.sh/'
-    STYLE: ClassVar[str] = None
-
-    def get_emoji(self, emoji: str, /) -> Optional[BytesIO]:
-        if self.STYLE is None:
-            raise TypeError('STYLE class variable unfilled.')
-
-        url = self.BASE_EMOJI_CDN_URL + quote_plus(emoji) + '?style=' + quote_plus(self.STYLE)
-        _to_catch = HTTPError if not _has_requests else requests.HTTPError
-
-        try:
-            return BytesIO(self.request(url))
-        except _to_catch:
-            pass
-
-
-class TwitterEmojiSource(EmojiCDNSource):
-    """A source that uses Twitter-style emojis. These are also the ones used in Discord."""
-    STYLE = 'twitter'
-
-
-class AppleEmojiSource(EmojiCDNSource):
-    """A source that uses Apple emojis."""
-    STYLE = 'apple'
-
-
-class GoogleEmojiSource(EmojiCDNSource):
-    """A source that uses Google emojis."""
-    STYLE = 'google'
-
-
-class MicrosoftEmojiSource(EmojiCDNSource):
-    """A source that uses Microsoft emojis."""
-    STYLE = 'microsoft'
-
-
-class SamsungEmojiSource(EmojiCDNSource):
-    """A source that uses Samsung emojis."""
-    STYLE = 'samsung'
-
-
-class WhatsAppEmojiSource(EmojiCDNSource):
-    """A source that uses WhatsApp emojis."""
-    STYLE = 'whatsapp'
-
-
-class FacebookEmojiSource(EmojiCDNSource):
-    """A source that uses Facebook emojis."""
-    STYLE = 'facebook'
-
-
-class MessengerEmojiSource(EmojiCDNSource):
-    """A source that uses Facebook Messenger's emojis."""
-    STYLE = 'messenger'
-
-
-class JoyPixelsEmojiSource(EmojiCDNSource):
-    """A source that uses JoyPixels' emojis."""
-    STYLE = 'joypixels'
-
-
-class OpenmojiEmojiSource(EmojiCDNSource):
-    """A source that uses Openmoji emojis."""
-    STYLE = 'openmoji'
-
-
-class EmojidexEmojiSource(EmojiCDNSource):
-    """A source that uses Emojidex emojis."""
-    STYLE = 'emojidex'
-
-
-class MozillaEmojiSource(EmojiCDNSource):
-    """A source that uses Mozilla's emojis."""
-    STYLE = 'mozilla'
-
-
-# Aliases
-Openmoji = OpenmojiEmojiSource
-FacebookMessengerEmojiSource = MessengerEmojiSource
-TwemojiEmojiSource = Twemoji = TwitterEmojiSource