critterchat 0.1.2__py3-none-any.whl

critterchat/__main__.py

@@ -0,0 +1,104 @@
+from gevent import monkey
+monkey.patch_all()
+
+import argparse  # noqa
+import logging  # noqa
+from flask.logging import default_handler  # noqa
+from gevent.ssl import Purpose, create_default_context  # noqa
+from werkzeug.middleware.proxy_fix import ProxyFix  # noqa
+
+from critterchat.http import app, config, socketio  # noqa
+
+from critterchat.config import Config, load_config  # noqa
+from critterchat.data import Data  # noqa
+from critterchat.service import AttachmentService, MessageService, UserService  # noqa
+
+# Since the sockets and REST files use decorators for hooking, simply importing these hooks the desired functions
+import critterchat.http.welcome  # noqa
+import critterchat.http.chat  # noqa
+import critterchat.http.account  # noqa
+import critterchat.http.upload  # noqa
+import critterchat.http.socket  # noqa
+
+# This is only hooked when local storage is enabled.
+from critterchat.http.attachments import attachments  # noqa
+
+
+logger = logging.getLogger(__name__)
+
+
+def perform_initialization_work(config: Config) -> None:
+    with Data.spawn(config) as data:
+        # Ensure that the default avatars are copied to the attachment storage system.
+        attachmentservice = AttachmentService(config, data)
+        logger.info("Creating any default attachments required.")
+        attachmentservice.create_default_attachments()
+        logger.info("Migrating any legacy attachments to current system.")
+        attachmentservice.migrate_legacy_attachments()
+
+        # Ensure that any nickname loopholes are fixed.
+        userservice = UserService(config, data)
+        logger.info("Migrating any legacy names to current rules.")
+        userservice.migrate_legacy_names()
+
+        # Ensure any per-room nicknames loopholes are fixed.
+        messageservice = MessageService(config, data)
+        logger.info("Migrating any per-room legacy names to current rules.")
+        messageservice.migrate_legacy_names()
+
+        logger.info("Done with initialization.")
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Run the chat application backend.")
+    parser.add_argument("-p", "--port", help="Port to listen on. Defaults to 5678", type=int, default=5678)
+    parser.add_argument("-d", "--debug", help="Enable debug mode. Defaults to off", action="store_true")
+    parser.add_argument("-s", "--sql-query-log", help="Enable logging of SQL queries. Defaults to off", action="store_true")
+    parser.add_argument("-n", "--nginx-proxy", help="Number of nginx proxies in front of this server. Defaults to 0", type=int, default=0)
+    parser.add_argument("-c", "--config", help="Config file to parse for instance settings. Defaults to config.yaml", type=str, default="config.yaml")
+    parser.add_argument("-e", "--cert", help="Certificate fullchain to use when directly hosting SSL traffic", type=str, default=None)
+    parser.add_argument("-k", "--cert-key", help="Certificate key to use with the fullchain when directly hosting SSL traffic", type=str, default=None)
+    args = parser.parse_args()
+
+    load_config(args.config, config)
+    app.secret_key = config.cookie_key
+
+    root_logger = logging.getLogger()
+    while root_logger.hasHandlers():
+        root_logger.removeHandler(logger.handlers[0])
+    default_handler.setFormatter(
+        logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+    )
+    root_logger.addHandler(default_handler)
+    root_logger.setLevel(logging.DEBUG if args.debug else logging.INFO)
+
+    # Gevent's logger has the wrong IP and is messy, shut it up.
+    gevent_logger = logging.getLogger("geventwebsocket.handler")
+    gevent_logger.setLevel(logging.WARNING)
+
+    if args.sql_query_log:
+        logging.getLogger("sqlalchemy.engine").setLevel(logging.INFO)
+
+    # Attach local storage handler if we're local attachment type.
+    if config.attachments.system == "local":
+        app.register_blueprint(attachments)
+
+    # If we're directly serving SSL, set that up here.
+    extra_args: dict[str, object] = {}
+    if args.cert and args.cert_key:
+        ssl_context = create_default_context(Purpose.CLIENT_AUTH)
+        ssl_context.load_cert_chain(args.cert, args.cert_key)
+        extra_args['ssl_context'] = ssl_context
+
+    # Perform any one-time initialization that needs to happen.
+    perform_initialization_work(config)
+
+    if args.nginx_proxy > 0:
+        logger.info(f"Fixing proxy headers with a depth of {args.nginx_proxy}")
+        app.wsgi_app = ProxyFix(app.wsgi_app, x_host=args.nginx_proxy, x_proto=args.nginx_proxy, x_for=args.nginx_proxy, x_prefix=args.nginx_proxy)  # type: ignore
+    logger.info(f"Running server listening on port {args.port}")
+    socketio.run(app, host='0.0.0.0', port=args.port, debug=args.debug, **extra_args)
+
+
+if __name__ == '__main__':
+    main()

critterchat/common/__init__.py

@@ -0,0 +1,18 @@
+from .aes import AESCipher
+from .text import convert_spaces, represents_real_text
+from .time import Time
+from .emoji import get_aliases_unicode_dict, emojize
+from .emojicategories import EMOJI_CATEGORIES
+from .enums import coerce_enum
+
+
+__all__ = [
+    "AESCipher",
+    "Time",
+    "get_aliases_unicode_dict",
+    "emojize",
+    "convert_spaces",
+    "represents_real_text",
+    "EMOJI_CATEGORIES",
+    "coerce_enum",
+]

critterchat/common/aes.py

@@ -0,0 +1,38 @@
+import base64
+import hashlib
+from Crypto import Random
+from Crypto.Cipher import AES
+
+
+class AESCipher:
+    """
+    Simple AES cipher used to provide cookie support to the frontend.
+    """
+
+    def __init__(self, key: str) -> None:
+        self.__padamt = 16
+        self.__key = hashlib.sha256(key.encode("utf-8")).digest()
+
+    def _pad(self, s: str) -> str:
+        intermediate = f"{len(s)}.{s}"
+        while len(intermediate) % self.__padamt != 0:
+            intermediate = intermediate + "-"
+        return intermediate
+
+    def _unpad(self, s: str) -> str:
+        length, string = s.split(".", 1)
+        intlength = int(length)
+        return string[:intlength]
+
+    def encrypt(self, raw: str) -> str:
+        raw = self._pad(raw)
+        random = Random.new()
+        iv = random.read(AES.block_size)
+        cipher = AES.new(self.__key, AES.MODE_CBC, iv)
+        return base64.b64encode(iv + cipher.encrypt(raw.encode("utf-8")), altchars=b"._").decode("utf-8")
+
+    def decrypt(self, encoded: str) -> str:
+        enc = base64.b64decode(encoded.encode("utf-8"), altchars=b"._")
+        iv = enc[: AES.block_size]
+        cipher = AES.new(self.__key, AES.MODE_CBC, iv)
+        return self._unpad(cipher.decrypt(enc[AES.block_size:]).decode("utf-8"))

critterchat/common/emoji.py

@@ -0,0 +1,94 @@
+import re
+from emoji import LANGUAGES, EMOJI_DATA, STATUS
+from typing import Match
+
+
+_EMOJI_UNICODE: dict[str, dict[str, str] | None] = {lang: None for lang in LANGUAGES}  # Cache for the language dicts
+_ALIASES_UNICODE: dict[str, str] = {}  # Cache for the aliases dict
+_BANNED_ALIASES: set[str] = {
+    ":egg2:",
+    ":cow2:",
+    ":point_up_2:",
+    ":cat2:",
+    ":dog2:",
+    ":mouse2:",
+    ":pencil2:",
+    ":pig2:",
+    ":rabbit2:",
+    ":tiger2:",
+    ":train2:",
+    ":whale2:",
+}  # Aliases that are pure duplicates that we don't want around.
+_RENAMED_ALIASES: dict[str, str] = {
+    ":emoji_modifier_fitzpatrick_type_1_2:": ":emoji_modifier_1_light_skin_tone:",
+    ":emoji_modifier_fitzpatrick_type_3:": ":emoji_modifier_2_medium-light_skin_tone:",
+    ":emoji_modifier_fitzpatrick_type_4:": ":emoji_modifier_3_medium_skin_tone:",
+    ":emoji_modifier_fitzpatrick_type_5:": ":emoji_modifier_4_medium-dark_skin_tone:",
+    ":emoji_modifier_fitzpatrick_type_6:": ":emoji_modifier_5_dark_skin_tone:",
+}  # Aliases that we want to rename for convenience.
+
+
+# Delimeters for regex.
+_DELIMITER = ':'
+_EMOJI_NAME_PATTERN = '\\w\\-&.’”“()!#*+,/«»\u0300\u0301\u0302\u0303\u0306\u0308\u030a\u0327\u064b\u064e\u064f\u0650\u0653\u0654\u3099\u30fb\u309a\u0655'
+_EMOJI_REGEX = re.compile(
+    f'({_DELIMITER}[{_EMOJI_NAME_PATTERN}]+{_DELIMITER})'
+)
+
+
+def _get_emoji_unicode_dict(lang: str) -> dict[str, str]:
+    """
+    Generate dict containing all fully-qualified and component emoji name for a language
+    The dict is only generated once per language and then cached in _EMOJI_UNICODE[lang]
+    """
+
+    if _EMOJI_UNICODE[lang] is None:
+        _EMOJI_UNICODE[lang] = {
+            data[lang]: emj for emj, data in EMOJI_DATA.items()
+            if lang in data and data['status'] <= STATUS['fully_qualified']
+        }
+
+    return _EMOJI_UNICODE[lang]  # type: ignore
+
+
+def get_aliases_unicode_dict() -> dict[str, str]:
+    """
+    Generate dict containing all fully-qualified and component aliases
+    The dict is only generated once and then cached in _ALIASES_UNICODE
+    """
+
+    if not _ALIASES_UNICODE:
+        _ALIASES_UNICODE.update(_get_emoji_unicode_dict('en'))
+        for emj, data in EMOJI_DATA.items():
+            if 'alias' in data and data['status'] <= STATUS['fully_qualified']:
+                for alias in data['alias']:
+                    if alias in _ALIASES_UNICODE:
+                        continue
+                    if alias in _BANNED_ALIASES:
+                        continue
+                    if alias in _RENAMED_ALIASES:
+                        alias = _RENAMED_ALIASES[alias]
+                    _ALIASES_UNICODE[alias] = emj
+
+        for off, val in enumerate(range(0x1F1E6, 0x1F200)):
+            ascval = chr(off + ord('a'))
+            _ALIASES_UNICODE[f":regional_indicator_{ascval}:"] = chr(val) + chr(0x200B)
+
+    return _ALIASES_UNICODE
+
+
+def emojize(msg: str) -> str:
+    """
+    Performs the same thing as emoji.emojize() but does not include banned aliases since it
+    instead uses the unicode dictionary from above. Allows us to sidestep the problem that
+    our frontend has one set of aliases (computed in get_aliases_unicode_dict) but using
+    emoji.emojize ends up using its own internal alias list.
+    """
+
+    aliases = get_aliases_unicode_dict()
+
+    def replace(match: Match[str]) -> str:
+        name_or_alias = match.group(1)
+        return aliases.get(name_or_alias, match.group(1))
+
+    return _EMOJI_REGEX.sub(replace, msg)