追加

modules/emojistore.py

@@ -0,0 +1,143 @@
+import orjson
+import sqlite3
+import requests
+import time
+import math
+import logging
+
+CACHE_EXPIRE_TIME = 60 * 60 * 12
+
+logger = logging.getLogger('EmojiStore')
+
+class EmojiStore:
+
+    def __init__(self, db, **kwargs):
+        self.db: sqlite3.Connection = db
+        self.db.row_factory = sqlite3.Row
+        cur = self.db.cursor()
+        cur.execute('CREATE TABLE IF NOT EXISTS emoji_cache(host TEXT, data TEXT, last_updated INTEGER)')
+        cur.close()
+
+        self.emoji_cache = {}
+        if kwargs.get('session'):
+            self.session = kwargs['session']
+        else:
+            self.session = requests.Session()
+            self.session.headers['User-Agent'] = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/108.0.0.0 Safari/537.36'
+    
+    def _generate_emoji_url(self, host, emoji: dict):
+        if emoji.get('url'):
+            return emoji['url']
+        else:
+            # v>=13?
+            return f'https://{host}/emoji/{emoji["name"]}.webp'
+    
+    def _fetch_nodeinfo(self, host):
+        r = self.session.get(f'https://{host}/.well-known/nodeinfo')
+        if r.status_code != 200:
+            logger.getChild('fetch_nodeinfo').error(f'Failed to fetch nodeinfo for {host} (well-known/nodeinfo)')
+            raise Exception(f'Failed to fetch nodeinfo for {host}')
+        res = orjson.loads(r.content)
+        if res.get('links'):
+            for link in res['links']:
+                if link['rel'].endswith('nodeinfo.diaspora.software/ns/schema/2.0'):
+                    r2 = self.session.get(link['href'])
+                    if r2.status_code != 200:
+                        logger.getChild('fetch_nodeinfo').error(f'Failed to fetch nodeinfo for {host} (nodeinfo)')
+                        raise Exception(f'Failed to fetch nodeinfo for {host}')
+                    return orjson.loads(r2.content)
+        logger.getChild('fetch_nodeinfo').error(f'Failed to fetch nodeinfo for {host}')
+        raise Exception(f'Failed to fetch nodeinfo for {host}')
+    
+    def _fetch_emoji_data(self, host):
+        logger.getChild('fetch_emoji_data').info(f'Fetching emoji data for {host}')
+        try:
+            ni = self._fetch_nodeinfo(host)
+            r = self.session.post(f'https://{host}/api/meta', headers={'Content-Type': 'application/json'}, data=b'{}')
+            if r.status_code != 200 and r.status_code != 404:
+                logger.getChild('fetch_emoji_data').error(f'Failed to fetch emoji data for {host} (api/meta)')
+                raise Exception(f'Failed to fetch emoji data for {host}')
+            if r.status_code != 404:
+                meta = orjson.loads(r.content)
+                v = meta['version'].split('.')
+                # Misskey v13以降は別エンドポイントに問い合わせ
+                if ni['software']['name'] == 'misskey' and int(v[0]) >= 13:
+                    r2 = self.session.post(f'https://{host}/api/emojis', headers={'Content-Type': 'application/json'}, data=b'{}')
+                    if r2.status_code != 200:
+                        logger.getChild('fetch_emoji_data').error(f'Failed to fetch emoji data for {host} (Misskey v13)')
+                        raise Exception(f'Failed to fetch emoji data for {host} (Misskey v13)')
+                    return orjson.loads(r2.content)['emojis']
+                else:
+                    return meta['emojis']
+            else:
+                # Mastodon/Pleroma?
+                r3 = self.session.get(f'https://{host}/api/v1/custom_emojis')
+                if r3.status_code != 200:
+                    logger.getChild('fetch_emoji_data').error(f'Failed to fetch emoji data for {host} (mastodon, pleroma)')
+                    raise Exception(f'Failed to fetch emoji data for {host} (mastodon, pleroma)')
+                res = orjson.loads(r3.content)
+                # Misskey形式に変換
+                return [{'name': x['shortcode'], 'url': x['static_url'], 'aliases': [''], 'category': ''} for x in res]
+        except:
+            return []
+    
+    def _download(self, host):
+        emoji_data = self._fetch_emoji_data(host)
+        cur = self.db.cursor()
+        cur.execute('REPLACE INTO emoji_cache(host, data, last_updated) VALUES (?, ?, ?)', (host, orjson.dumps(emoji_data), math.floor(time.time())))
+        self.db.commit()
+        self.emoji_cache[host] = emoji_data
+
+    def _load(self, host) -> list:
+        emojis = []
+        if host in self.emoji_cache.keys():
+            emojis = self.emoji_cache[host]
+        else:
+            cur = self.db.cursor()
+            cur.execute('SELECT * FROM emoji_cache WHERE host = ?', (host,))
+            row = cur.fetchone()
+            if row is None:
+                logger.getChild('load').error(f'emoji data not found. fetching')
+                self._download(host)
+                return self._load(host)
+            else:
+                expire = CACHE_EXPIRE_TIME
+                # 前回取得失敗してる？
+                if row['data'] == '[]':
+                    expire = 60 * 5
+                if math.floor(time.time()) - row['last_updated'] > expire:
+                    logger.getChild('load').error(f'emoji cache expired. refreshing')
+                    self._download(host)
+                    return self._load(host)
+            self.emoji_cache[host] = orjson.loads(row['data'])
+            emojis = self.emoji_cache[host]
+        
+        return emojis
+    
+    # ----------------------
+
+    def refresh(self, host):
+        self._download(host)
+    
+    def find_by_keyword(self, host, k) -> list:
+        emojis = self._load(host)
+        res = []
+        for emoji in emojis:
+            if k in emoji['name'].lower():
+                res.append({'name': emoji['name'], 'url': self._generate_emoji_url(host, emoji)})
+        return res
+    
+    def find_by_alias(self, host, t) -> list:
+        emojis = self._load(host)
+        res = []
+        for emoji in emojis:
+            if t in emoji['aliases']:
+                res.append({'name': emoji['name'], 'url': self._generate_emoji_url(host, emoji)})
+        return res
+    
+    def get(self, host, name):
+        emojis = self._load(host)
+        for emoji in emojis:
+            if emoji['name'] == name:
+                return {'name': emoji['name'], 'url': self._generate_emoji_url(host, emoji)}
+        return None

pilmoji/__init__.py

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

pilmoji/core.py

@@ -0,0 +1,352 @@
+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

@@ -0,0 +1,171 @@
+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

@@ -0,0 +1,253 @@
+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