slidge 0.1.2__py3-none-any.whl → 0.2.0__py3-none-any.whl

slidge/__init__.py

@@ -13,13 +13,12 @@ from .contact import LegacyContact, LegacyRoster  # noqa: F401
 from .core import config as global_config  # noqa: F401
 from .core.gateway import BaseGateway  # noqa: F401
 from .core.session import BaseSession  # noqa: F401
+from .db import GatewayUser  # noqa: F401
 from .group import LegacyBookmarks, LegacyMUC, LegacyParticipant  # noqa: F401
-from .util.db import GatewayUser, user_store  # noqa: F401
+from .main import main as main_func
 from .util.types import MucType  # noqa: F401
 from .util.util import addLoggingLevel
 
-from .__main__ import main  # isort: skip
-
 
 def entrypoint(module_name: str) -> None:
     """
@@ -29,7 +28,7 @@ def entrypoint(module_name: str) -> None:
     :param module_name: An importable :term:`Legacy Module`.
     """
     sys.argv.extend(["--legacy", module_name])
-    main()
+    main_func()
 
 
 def formatwarning(message, category, filename, lineno, line=""):
@@ -54,7 +53,6 @@ __all__ = [
     # "FormField",
     # "SearchResult",
     "entrypoint",
-    "user_store",
     "global_config",
 ]
 

slidge/__main__.py

@@ -1,198 +1,3 @@
-"""
-Slidge can be configured via CLI args, environment variables and/or INI files.
+from slidge.main import main
 
-To use env vars, use this convention: ``--home-dir`` becomes ``HOME_DIR``.
-
-Everything in ``/etc/slidge/conf.d/*`` is automatically used.
-To use a plugin-specific INI file, put it in another dir,
-and launch slidge with ``-c /path/to/plugin-specific.conf``.
-Use the long version of the CLI arg without the double dash prefix inside this
-INI file, eg ``debug=true``.
-
-An example configuration file is available at
-https://git.sr.ht/~nicoco/slidge/tree/master/item/dev/confs/slidge-example.ini
-"""
-
-import asyncio
-import importlib
-import logging
-import os
-import signal
-from pathlib import Path
-
-import configargparse
-
-from slidge import BaseGateway
-from slidge.core import config
-from slidge.core.cache import avatar_cache
-from slidge.migration import migrate
-from slidge.util.conf import ConfigModule
-from slidge.util.db import user_store
-from slidge.util.util import get_version  # noqa: F401
-
-
-class MainConfig(ConfigModule):
-    def update_dynamic_defaults(self, args):
-        # force=True is needed in case we call a logger before this is reached,
-        # or basicConfig has no effect
-        logging.basicConfig(
-            level=args.loglevel,
-            filename=args.log_file,
-            force=True,
-            format=args.log_format,
-        )
-
-        if args.home_dir is None:
-            args.home_dir = Path("/var/lib/slidge") / str(args.jid)
-
-        if args.user_jid_validator is None:
-            args.user_jid_validator = ".*@" + args.server
-
-
-class SigTermInterrupt(Exception):
-    pass
-
-
-def get_configurator():
-    p = configargparse.ArgumentParser(
-        default_config_files=os.getenv(
-            "SLIDGE_CONF_DIR", "/etc/slidge/conf.d/*.conf"
-        ).split(":"),
-        description=__doc__,
-    )
-    p.add_argument(
-        "-c",
-        "--config",
-        help="Path to a INI config file.",
-        env_var="SLIDGE_CONFIG",
-        is_config_file=True,
-    )
-    p.add_argument(
-        "-q",
-        "--quiet",
-        help="loglevel=WARNING",
-        action="store_const",
-        dest="loglevel",
-        const=logging.WARNING,
-        default=logging.INFO,
-        env_var="SLIDGE_QUIET",
-    )
-    p.add_argument(
-        "-d",
-        "--debug",
-        help="loglevel=DEBUG",
-        action="store_const",
-        dest="loglevel",
-        const=logging.DEBUG,
-        env_var="SLIDGE_DEBUG",
-    )
-    p.add_argument(
-        "--version",
-        action="version",
-        version=f"%(prog)s {__version__}",
-    )
-    configurator = MainConfig(config, p)
-    return configurator
-
-
-def get_parser():
-    return get_configurator().parser
-
-
-def configure():
-    configurator = get_configurator()
-    args, unknown_argv = configurator.set_conf()
-
-    if not (h := config.HOME_DIR).exists():
-        logging.info("Creating directory '%s'", h)
-        h.mkdir()
-
-    db_file = config.HOME_DIR / "slidge.db"
-    user_store.set_file(db_file, args.secret_key)
-
-    avatar_cache.set_dir(h / "slidge_avatars_v2")
-
-    config.UPLOAD_REQUESTER = config.UPLOAD_REQUESTER or config.JID.bare
-
-    return unknown_argv
-
-
-def handle_sigterm(_signum, _frame):
-    logging.info("Caught SIGTERM")
-    raise SigTermInterrupt
-
-
-def main():
-    signal.signal(signal.SIGTERM, handle_sigterm)
-
-    unknown_argv = configure()
-    logging.info("Starting slidge version %s", __version__)
-
-    legacy_module = importlib.import_module(config.LEGACY_MODULE)
-    logging.debug("Legacy module: %s", dir(legacy_module))
-    logging.info(
-        "Starting legacy module: '%s' version %s",
-        config.LEGACY_MODULE,
-        getattr(legacy_module, "__version__", "No version"),
-    )
-
-    if plugin_config_obj := getattr(
-        legacy_module, "config", getattr(legacy_module, "Config", None)
-    ):
-        logging.debug("Found a config object in plugin: %r", plugin_config_obj)
-        ConfigModule.ENV_VAR_PREFIX += (
-            f"_{config.LEGACY_MODULE.split('.')[-1].upper()}_"
-        )
-        logging.debug("Env var prefix: %s", ConfigModule.ENV_VAR_PREFIX)
-        ConfigModule(plugin_config_obj).set_conf(unknown_argv)
-    else:
-        if unknown_argv:
-            raise RuntimeError("Some arguments have not been recognized", unknown_argv)
-
-    migrate()
-
-    gateway: BaseGateway = BaseGateway.get_unique_subclass()()
-    avatar_cache.http = gateway.http
-    gateway.connect()
-
-    return_code = 0
-    try:
-        gateway.loop.run_forever()
-    except KeyboardInterrupt:
-        logging.debug("Received SIGINT")
-    except SigTermInterrupt:
-        logging.debug("Received SIGTERM")
-    except SystemExit as e:
-        return_code = e.code  # type: ignore
-        logging.debug("Exit called")
-    except Exception as e:
-        return_code = 2
-        logging.exception("Exception in __main__")
-        logging.exception(e)
-    finally:
-        if gateway.has_crashed:
-            if return_code != 0:
-                logging.warning("Return code has been set twice. Please report this.")
-            return_code = 3
-        if gateway.is_connected():
-            logging.debug("Gateway is connected, cleaning up")
-            gateway.loop.run_until_complete(asyncio.gather(*gateway.shutdown()))
-            gateway.disconnect()
-            gateway.loop.run_until_complete(gateway.disconnected)
-        else:
-            logging.debug("Gateway is not connected, no need to clean up")
-        user_store.close()
-        avatar_cache.close()
-        gateway.loop.run_until_complete(gateway.http.close())
-        logging.info("Successful clean shut down")
-    logging.debug("Exiting with code %s", return_code)
-    exit(return_code)
-
-
-# this should be modified before publish, but if someone cloned from the repo,
-# it can help
-__version__ = get_version()
-
-
-if __name__ == "__main__":
-    main()
+main()

slidge/__version__.py

@@ -0,0 +1,5 @@
+from slidge.util.util import get_version  # noqa: F401
+
+# this is modified before publish, but if someone cloned from the repo,
+# it can help
+__version__ = "0.2.0"

slidge/command/adhoc.py

@@ -9,11 +9,14 @@ from slixmpp.exceptions import XMPPError
 from slixmpp.plugins.xep_0004 import Form as SlixForm  # type: ignore[attr-defined]
 from slixmpp.plugins.xep_0030.stanza.items import DiscoItems
 
+from ..core import config
+from ..util.util import strip_leading_emoji
 from . import Command, CommandResponseType, Confirmation, Form, TableResult
 from .base import FormField
+from .categories import CommandCategory
 
 if TYPE_CHECKING:
-    from ..core.gateway.base import BaseGateway
+    from ..core.gateway import BaseGateway
     from ..core.session import BaseSession
 
 
@@ -46,20 +49,27 @@ class AdhocProvider:
         return await self.__handle_result(session, result, adhoc_session)
 
     async def __handle_category_list(
-        self, category: str, iq: Iq, adhoc_session: AdhocSessionType
+        self, category: CommandCategory, iq: Iq, adhoc_session: AdhocSessionType
     ) -> AdhocSessionType:
-        session = self.xmpp.get_session_from_stanza(iq)
-        commands = []
-        for command in self._categories[category]:
+        try:
+            session = self.xmpp.get_session_from_stanza(iq)
+        except XMPPError:
+            session = None
+        commands: dict[str, Command] = {}
+        for command in self._categories[category.node]:
             try:
                 command.raise_if_not_authorized(iq.get_from())
             except XMPPError:
                 continue
-            commands.append(command)
+            commands[command.NODE] = command
+        if len(commands) == 0:
+            raise XMPPError(
+                "not-authorized", "There is no command you can run in this category"
+            )
         return await self.__handle_result(
             session,
             Form(
-                category,
+                category.name,
                 "",
                 [
                     FormField(
@@ -67,8 +77,11 @@ class AdhocProvider:
                         label="Command",
                         type="list-single",
                         options=[
-                            {"label": command.NAME, "value": str(i)}
-                            for i, command in enumerate(commands)
+                            {
+                                "label": strip_leading_emoji_if_needed(command.NAME),
+                                "value": command.NODE,
+                            }
+                            for command in commands.values()
                         ],
                     )
                 ],
@@ -79,12 +92,12 @@ class AdhocProvider:
 
     async def __handle_category_choice(
         self,
-        commands: list[Command],
+        commands: dict[str, Command],
         form_values: dict[str, str],
         session: "BaseSession[Any, Any]",
         jid: JID,
     ):
-        command = commands[int(form_values["command"])]
+        command = commands[form_values["command"]]
         result = await self.__wrap_handler(command.run, session, jid)
         return result
 
@@ -200,19 +213,23 @@ class AdhocProvider:
             self.xmpp.plugin["xep_0050"].add_command(  # type: ignore[no-untyped-call]
                 jid=jid,
                 node=command.NODE,
-                name=command.NAME,
+                name=strip_leading_emoji_if_needed(command.NAME),
                 handler=partial(self.__wrap_initial_handler, command),
             )
         else:
-            if category not in self._categories:
-                self._categories[category] = list[Command]()
+            if isinstance(category, str):
+                category = CommandCategory(category, category)
+            node = category.node
+            name = category.name
+            if node not in self._categories:
+                self._categories[node] = list[Command]()
                 self.xmpp.plugin["xep_0050"].add_command(  # type: ignore[no-untyped-call]
                     jid=jid,
-                    node=category,
-                    name=category,
+                    node=node,
+                    name=strip_leading_emoji_if_needed(name),
                     handler=partial(self.__handle_category_list, category),
                 )
-            self._categories[category].append(command)
+            self._categories[node].append(command)
 
     async def get_items(self, jid: JID, node: str, iq: Iq) -> DiscoItems:
         """
@@ -255,4 +272,10 @@ class AdhocProvider:
         return filtered_items
 
 
+def strip_leading_emoji_if_needed(text: str) -> str:
+    if config.STRIP_LEADING_EMOJI_ADHOC:
+        return strip_leading_emoji(text)
+    return text
+
+
 log = logging.getLogger(__name__)

slidge/command/admin.py

@@ -1,5 +1,6 @@
 # Commands only accessible for slidge admins
 import functools
+import importlib
 import logging
 from datetime import datetime
 from typing import Any, Optional
@@ -7,9 +8,10 @@ from typing import Any, Optional
 from slixmpp import JID
 from slixmpp.exceptions import XMPPError
 
-from ..util.db import user_store
+from ..core import config
 from ..util.types import AnyBaseSession
 from .base import (
+    NODE_PREFIX,
     Command,
     CommandAccess,
     Confirmation,
@@ -20,6 +22,8 @@ from .base import (
 )
 from .categories import ADMINISTRATION
 
+NODE_PREFIX = NODE_PREFIX + "admin/"
+
 
 class AdminCommand(Command):
     ACCESS = CommandAccess.ADMIN_ONLY
@@ -29,17 +33,18 @@ class AdminCommand(Command):
 class ListUsers(AdminCommand):
     NAME = "👤 List registered users"
     HELP = "List the users registered to this gateway"
-    NODE = CHAT_COMMAND = "list_users"
+    CHAT_COMMAND = "list_users"
+    NODE = NODE_PREFIX + CHAT_COMMAND
 
     async def run(self, _session, _ifrom, *_):
         items = []
-        for u in user_store.get_all():
+        for u in self.xmpp.store.users.get_all():
             d = u.registration_date
             if d is None:
                 joined = ""
             else:
                 joined = d.isoformat(timespec="seconds")
-            items.append({"jid": u.bare_jid, "joined": joined})
+            items.append({"jid": u.jid.bare, "joined": joined})
         return TableResult(
             description="List of registered users",
             fields=[FormField("jid", type="jid-single"), FormField("joined")],
@@ -50,13 +55,14 @@ class ListUsers(AdminCommand):
 class SlidgeInfo(AdminCommand):
     NAME = "ℹ️ Server information"
     HELP = "List the users registered to this gateway"
-    NODE = CHAT_COMMAND = "info"
+    CHAT_COMMAND = "info"
+    NODE = NODE_PREFIX + CHAT_COMMAND
     ACCESS = CommandAccess.ANY
 
     async def run(self, _session, _ifrom, *_):
-        from ..__main__ import __version__
+        from slidge.__version__ import __version__
 
-        start = self.xmpp.datetime_started
+        start = self.xmpp.datetime_started  # type:ignore
         uptime = datetime.now() - start
 
         if uptime.days:
@@ -91,8 +97,12 @@ class SlidgeInfo(AdminCommand):
             [a for a in (days_ago, hours_ago, minutes_ago, seconds_ago) if a]
         )
 
+        legacy_module = importlib.import_module(config.LEGACY_MODULE)
+        version = getattr(legacy_module, "__version__", "No version")
+
         return (
-            f"{self.xmpp.COMPONENT_NAME} version {__version__}\n"
+            f"{self.xmpp.COMPONENT_NAME} (slidge core {__version__},"
+            f" {config.LEGACY_MODULE} {version})\n"
             f"Up since {start:%Y-%m-%d %H:%M} ({ago} ago)"
         )
 
@@ -100,7 +110,8 @@ class SlidgeInfo(AdminCommand):
 class DeleteUser(AdminCommand):
     NAME = "❌ Delete a user"
     HELP = "Unregister a user from the gateway"
-    NODE = CHAT_COMMAND = "delete_user"
+    CHAT_COMMAND = "delete_user"
+    NODE = NODE_PREFIX + CHAT_COMMAND
 
     async def run(self, _session, _ifrom, *_):
         return Form(
@@ -114,7 +125,7 @@ class DeleteUser(AdminCommand):
         self, form_values: FormValues, _session: AnyBaseSession, _ifrom: JID
     ) -> Confirmation:
         jid: JID = form_values.get("jid")  # type:ignore
-        user = user_store.get_by_jid(jid)
+        user = self.xmpp.store.users.get(jid)
         if user is None:
             raise XMPPError("item-not-found", text=f"There is no user '{jid}'")
 
@@ -127,7 +138,7 @@ class DeleteUser(AdminCommand):
     async def finish(
         self, _session: Optional[AnyBaseSession], _ifrom: JID, jid: JID
     ) -> None:
-        user = user_store.get_by_jid(jid)
+        user = self.xmpp.store.users.get(jid)
         if user is None:
             raise XMPPError("bad-request", f"{jid} has no account here!")
         await self.xmpp.unregister_user(user)
@@ -136,7 +147,8 @@ class DeleteUser(AdminCommand):
 class ChangeLoglevel(AdminCommand):
     NAME = "📋 Change the verbosity of the logs"
     HELP = "Set the logging level"
-    NODE = CHAT_COMMAND = "loglevel"
+    CHAT_COMMAND = "loglevel"
+    NODE = NODE_PREFIX + CHAT_COMMAND
 
     async def run(self, _session, _ifrom, *_):
         return Form(

slidge/command/base.py

@@ -6,9 +6,9 @@ from typing import (
     Any,
     Awaitable,
     Callable,
-    Collection,
     Iterable,
     Optional,
+    Sequence,
     Type,
     TypedDict,
     Union,
@@ -23,12 +23,14 @@ from slixmpp.plugins.xep_0004 import (
 from slixmpp.types import JidStr
 
 from ..core import config
-from ..util.db import user_store
 from ..util.types import AnyBaseSession, FieldType
 
+NODE_PREFIX = "https://slidge.im/command/core/"
+
 if TYPE_CHECKING:
     from ..core.gateway import BaseGateway
     from ..core.session import BaseSession
+    from .categories import CommandCategory
 
 
 HandlerType = Union[
@@ -55,11 +57,11 @@ class TableResult:
     Structured data as the result of a command
     """
 
-    fields: Collection["FormField"]
+    fields: Sequence["FormField"]
     """
     The 'columns names' of the table.
     """
-    items: Collection[dict[str, Union[str, JID]]]
+    items: Sequence[dict[str, Union[str, JID]]]
     """
     The rows of the table. Each row is a dict where keys are the fields ``var``
     attribute.
@@ -150,7 +152,7 @@ class Form:
 
     title: str
     instructions: str
-    fields: Collection["FormField"]
+    fields: Sequence["FormField"]
     handler: FormHandlerType
     handler_args: Iterable[Any] = field(default_factory=list)
     handler_kwargs: dict[str, Any] = field(default_factory=dict)
@@ -179,8 +181,8 @@ class Form:
         """
         form = SlixForm()  # type: ignore[no-untyped-call]
         form["type"] = "form"
-        form["instructions"] = self.instructions
         form["title"] = self.title
+        form["instructions"] = self.instructions
         for fi in self.fields:
             form.append(fi.get_xml())
         return form
@@ -348,7 +350,7 @@ class Command(ABC):
     Who can use this command
     """
 
-    CATEGORY: Optional[str] = None
+    CATEGORY: Optional[Union[str, "CommandCategory"]] = None
     """
     If used, the command will be under this top-level category.
     Use the same string for several commands to group them.
@@ -382,7 +384,7 @@ class Command(ABC):
         raise XMPPError("feature-not-implemented")
 
     def _get_session(self, jid: JID) -> Optional["BaseSession[Any, Any]"]:
-        user = user_store.get_by_jid(jid)
+        user = self.xmpp.store.users.get(jid)
         if user is None:
             return None
 

slidge/command/categories.py

@@ -1,3 +1,13 @@
-ADMINISTRATION = "🛷️ Slidge administration"
-CONTACTS = "👤 Contacts"
-GROUPS = "👥 Groups"
+from typing import NamedTuple
+
+from .base import NODE_PREFIX
+
+
+class CommandCategory(NamedTuple):
+    name: str
+    node: str
+
+
+ADMINISTRATION = CommandCategory("🛷️ Slidge administration", NODE_PREFIX + "admin")
+CONTACTS = CommandCategory("👤 Contacts", NODE_PREFIX + "contacts")
+GROUPS = CommandCategory("👥 Groups", NODE_PREFIX + "groups")

slidge/command/chat_command.py

@@ -13,6 +13,7 @@ from slixmpp.exceptions import XMPPError
 from slixmpp.types import JidStr, MessageTypes
 
 from . import Command, CommandResponseType, Confirmation, Form, TableResult
+from .categories import CommandCategory
 
 if TYPE_CHECKING:
     from ..core.gateway import BaseGateway
@@ -153,6 +154,9 @@ class ChatCommandProvider:
         self.xmpp.delivery_receipt.ack(msg)
         return await self._handle_result(result, msg, session)
 
+    def __make_uri(self, body: str) -> str:
+        return f"xmpp:{self.xmpp.boundjid.bare}?message;body={body}"
+
     async def _handle_result(self, result: CommandResponseType, msg: Message, session):
         if isinstance(result, str) or result is None:
             reply = msg.reply()
@@ -175,9 +179,14 @@ class ChatCommandProvider:
                         ).send()
                     if f.options:
                         for o in f.options:
-                            msg.reply(f"{o['value']} -- {o['label']}").send()
+                            msg.reply(
+                                f"{o['label']}: {self.__make_uri(o['value'])}"
+                            ).send()
                     if f.value:
                         msg.reply(f"Default: {f.value}").send()
+                    if f.type == "boolean":
+                        msg.reply("yes: " + self.__make_uri("yes")).send()
+                        msg.reply("no: " + self.__make_uri("no")).send()
 
                     ans = await self.xmpp.input(
                         msg.get_from(), (f.label or f.var) + "? (or 'abort')"
@@ -186,6 +195,12 @@ class ChatCommandProvider:
                         return await self._handle_result(
                             "Command aborted", msg, session
                         )
+                    if f.type == "boolean":
+                        if ans.lower() == "yes":
+                            ans = "true"
+                        else:
+                            ans = "false"
+
                     if f.type.endswith("multi"):
                         form_values[f.var] = f.validate(ans.split(" "))
                     else:
@@ -266,7 +281,19 @@ class ChatCommandProvider:
     def _help(self, mfrom: JID):
         msg = "Available commands:"
         for c in sorted(
-            self._commands.values(), key=lambda co: (co.CATEGORY or "", co.CHAT_COMMAND)
+            self._commands.values(),
+            key=lambda co: (
+                (
+                    co.CATEGORY
+                    if isinstance(co.CATEGORY, str)
+                    else (
+                        co.CATEGORY.name
+                        if isinstance(co.CATEGORY, CommandCategory)
+                        else ""
+                    )
+                ),
+                co.CHAT_COMMAND,
+            ),
         ):
             try:
                 c.raise_if_not_authorized(mfrom)