slidge 0.2.11__py3-none-any.whl → 0.3.0__py3-none-any.whl

slidge/util/conf.py

@@ -1,7 +1,7 @@
 import logging
 from functools import cached_property
 from types import GenericAlias
-from typing import Optional, Union, get_args, get_origin, get_type_hints
+from typing import Any, Optional, Union, cast, get_args, get_origin, get_type_hints
 
 import configargparse
 
@@ -11,31 +11,31 @@ class Option:
     DYNAMIC_DEFAULT_SUFFIX = "__DYNAMIC_DEFAULT"
     SHORT_SUFFIX = "__SHORT"
 
-    def __init__(self, parent: "ConfigModule", name: str):
+    def __init__(self, parent: "ConfigModule", name: str) -> None:
         self.parent = parent
         self.config_obj = parent.config_obj
         self.name = name
 
     @cached_property
-    def doc(self):
-        return getattr(self.config_obj, self.name + self.DOC_SUFFIX)
+    def doc(self) -> str:
+        return getattr(self.config_obj, self.name + self.DOC_SUFFIX)  # type:ignore
 
     @cached_property
-    def required(self):
+    def required(self) -> bool:
         return not hasattr(
             self.config_obj, self.name + self.DYNAMIC_DEFAULT_SUFFIX
         ) and not hasattr(self.config_obj, self.name)
 
     @cached_property
-    def default(self):
+    def default(self) -> Any:
         return getattr(self.config_obj, self.name, None)
 
     @cached_property
-    def short(self):
+    def short(self) -> str | None:
         return getattr(self.config_obj, self.name + self.SHORT_SUFFIX, None)
 
     @cached_property
-    def nargs(self):
+    def nargs(self) -> str | int | None:
         type_ = get_type_hints(self.config_obj).get(self.name, type(self.default))
 
         if isinstance(type_, GenericAlias):
@@ -44,9 +44,10 @@ class Option:
                 return "*"
             else:
                 return len(args)
+        return None
 
     @cached_property
-    def type(self):
+    def type(self) -> Any:
         type_ = get_type_hints(self.config_obj).get(self.name, type(self.default))
 
         if _is_optional(type_):
@@ -58,14 +59,14 @@ class Option:
         return type_
 
     @cached_property
-    def names(self):
+    def names(self) -> list[str]:
         res = ["--" + self.name.lower().replace("_", "-")]
         if s := self.short:
             res.append("-" + s)
         return res
 
     @cached_property
-    def kwargs(self):
+    def kwargs(self) -> dict[str, Any]:
         kwargs = dict(
             required=self.required,
             help=self.doc,
@@ -87,7 +88,7 @@ class Option:
             kwargs["nargs"] = n
         return kwargs
 
-    def name_to_env_var(self):
+    def name_to_env_var(self) -> str:
         return self.parent.ENV_VAR_PREFIX + self.name
 
 
@@ -96,10 +97,10 @@ class ConfigModule:
 
     def __init__(
         self,
-        config_obj,
+        config_obj: Any,
         parser: Optional[configargparse.ArgumentParser] = None,
         skip_options: tuple[str, ...] = (),
-    ):
+    ) -> None:
         self.config_obj = config_obj
         if parser is None:
             parser = configargparse.ArgumentParser()
@@ -108,7 +109,7 @@ class ConfigModule:
         self.skip_options = skip_options
         self.add_options_to_parser(skip_options)
 
-    def _list_options(self):
+    def _list_options(self) -> set[str]:
         return {
             o
             for o in (set(dir(self.config_obj)) | set(get_type_hints(self.config_obj)))
@@ -118,7 +119,9 @@ class ConfigModule:
             and o.lower() not in self.skip_options
         }
 
-    def set_conf(self, argv: Optional[list[str]] = None):
+    def set_conf(
+        self, argv: Optional[list[str]] = None
+    ) -> tuple[configargparse.Namespace, list[str]]:
         if argv is not None:
             # this is ugly, but necessary because for plugin config, we used
             # remaining argv.
@@ -156,7 +159,10 @@ class ConfigModule:
                     upper = _argv_to_option_name(a)
                     opt = options_long.get(upper)
                     if opt and opt.type is bool:
-                        if _argv_to_option_name(aa) not in options_long:
+                        if (
+                            not aa.startswith("-")
+                            and _argv_to_option_name(aa) not in options_long
+                        ):
                             log.debug("Removing %s from argv", aa)
                             skip_next = True
 
@@ -186,7 +192,7 @@ class ConfigModule:
             res.append(Option(self, opt))
         return res
 
-    def add_options_to_parser(self, skip_options: tuple[str, ...]):
+    def add_options_to_parser(self, skip_options: tuple[str, ...]) -> None:
         skip_options = tuple(o.lower() for o in skip_options)
         p = self.parser
         for o in sorted(self.options, key=lambda x: (not x.required, x.name)):
@@ -194,11 +200,11 @@ class ConfigModule:
                 continue
             p.add_argument(*o.names, **o.kwargs)
 
-    def update_dynamic_defaults(self, args):
+    def update_dynamic_defaults(self, args: configargparse.Namespace) -> None:
         pass
 
 
-def _is_optional(t):
+def _is_optional(t: Any) -> bool:
     if get_origin(t) is Union:
         args = get_args(t)
         if len(args) == 2 and isinstance(None, args[1]):
@@ -206,7 +212,7 @@ def _is_optional(t):
     return False
 
 
-def _argv_to_option_name(arg: str):
+def _argv_to_option_name(arg: str) -> str:
     return arg.upper().removeprefix("--").replace("-", "_")
 
 

slidge/util/jid_escaping.py

@@ -29,7 +29,7 @@ JID_UNESCAPE_TRANSFORMATIONS = {
 
 
 @lru_cache(1000)
-def unescape_node(node: str):
+def unescape_node(node: str) -> str:
     """Unescape a local portion of a JID."""
     unescaped = []
     seq = ""

slidge/{core/mixins → util}/lock.py

@@ -1,16 +1,16 @@
 import asyncio
 import logging
 from contextlib import asynccontextmanager
-from typing import Hashable
+from typing import Any, AsyncIterator, Hashable
 
 
 class NamedLockMixin:
-    def __init__(self, *a, **k):
+    def __init__(self, *a: Any, **k: Any) -> None:
         super().__init__(*a, **k)
         self.__locks = dict[Hashable, asyncio.Lock]()
 
     @asynccontextmanager
-    async def lock(self, id_: Hashable):
+    async def lock(self, id_: Hashable) -> AsyncIterator[None]:
         log.trace("getting %s", id_)  # type:ignore
         locks = self.__locks
         if not locks.get(id_):
@@ -21,13 +21,13 @@ class NamedLockMixin:
                 yield
         finally:
             log.trace("releasing %s", id_)  # type:ignore
-            waiters = locks[id_]._waiters  # type:ignore
+            waiters = locks[id_]._waiters
             if not waiters:
                 del locks[id_]
                 log.trace("erasing %s", id_)  # type:ignore
 
-    def get_lock(self, id_: Hashable):
+    def get_lock(self, id_: Hashable) -> asyncio.Lock | None:
         return self.__locks.get(id_)
 
 
-log = logging.getLogger(__name__)  # type:ignore
+log = logging.getLogger(__name__)

slidge/util/test.py

@@ -43,19 +43,25 @@ from slidge import (
 from ..command import Command
 from ..core import config
 from ..core.config import _TimedeltaSeconds
-from ..core.pubsub import PepAvatar, PepNick
 from ..db import SlidgeStore
 from ..db.avatar import avatar_cache
 from ..db.meta import Base
-from ..db.models import Contact
+from ..db.models import Contact, GatewayUser
 
 
 class SlixTestPlus(SlixTest):
-    def setUp(self):
+    def setUp(self) -> None:
         super().setUp()
         Error.namespace = "jabber:component:accept"
 
-    def check(self, stanza, criteria, method="exact", defaults=None, use_values=True):
+    def check(
+        self,
+        stanza,
+        criteria,
+        method: str = "exact",
+        defaults=None,
+        use_values: bool = True,
+    ):
         """
         Create and compare several stanza objects to a correct XML string.
 
@@ -174,7 +180,9 @@ class SlixTestPlus(SlixTest):
                     )
             self.assertTrue(result, debug)
 
-    def next_sent(self, timeout=0.05) -> Optional[Union[Message, Iq, Presence]]:
+    def next_sent(
+        self, timeout: float = 0.05
+    ) -> Optional[Union[Message, Iq, Presence]]:
         self.wait_for_send_queue()
         sent = self.xmpp.socket.next_sent(timeout=timeout)
         if sent is None:
@@ -197,13 +205,11 @@ class SlidgeTest(SlixTestPlus):
         home_dir = Path(tempfile.mkdtemp())
         user_jid_validator = ".*"
         admins: list[str] = []
-        no_roster_push = False
         upload_requester = None
         ignore_delay_threshold = _TimedeltaSeconds("300")
-        last_seen_fallback = True
 
     @classmethod
-    def setUpClass(cls):
+    def setUpClass(cls) -> None:
         for k, v in vars(cls.Config).items():
             setattr(config, k.upper(), v)
 
@@ -237,8 +243,6 @@ class SlidgeTest(SlixTestPlus):
         except Exception:
             raise
         self.xmpp.TEST_MODE = True
-        PepNick.contact_store = self.xmpp.store.contacts
-        PepAvatar.store = self.xmpp.store
         avatar_cache.store = self.xmpp.store.avatars
         avatar_cache.set_dir(Path(tempfile.mkdtemp()))
         self.xmpp._always_send_everything = True
@@ -273,22 +277,20 @@ class SlidgeTest(SlixTestPlus):
         self.xmpp.use_presence_ids = False
         Error.namespace = "jabber:component:accept"
 
-    def tearDown(self):
+    def tearDown(self) -> None:
         self.db_engine.echo = False
         super().tearDown()
-        import slidge.db.store
-
-        if slidge.db.store._session is not None:
-            slidge.db.store._session.commit()
-            slidge.db.store._session = None
         Base.metadata.drop_all(self.xmpp.store._engine)
 
-    def setup_logged_session(self, n_contacts=0):
-        user = self.xmpp.store.users.new(
-            JID("romeo@montague.lit/gajim"), {"username": "romeo", "city": ""}
-        )
-        user.preferences = {"sync_avatar": True, "sync_presence": True}
-        self.xmpp.store.users.update(user)
+    def setup_logged_session(self, n_contacts: int = 0) -> None:
+        with self.xmpp.store.session() as orm:
+            user = GatewayUser(
+                jid=JID("romeo@montague.lit/gajim").bare,
+                legacy_module_data={"username": "romeo", "city": ""},
+                preferences={"sync_avatar": True, "sync_presence": True},
+            )
+            orm.add(user)
+            orm.commit()
 
         with self.xmpp.store.session() as session:
             session.execute(delete(Contact))
@@ -308,9 +310,8 @@ class SlidgeTest(SlixTestPlus):
         if BaseGateway.get_self_or_unique_subclass().GROUPS:
             stanza = self.next_sent()
             assert "syncing groups" in stanza["status"].lower(), stanza
-        for _ in range(n_contacts):
-            probe = self.next_sent()
-            assert probe.get_type() == "probe"
+        probe = self.next_sent()
+        assert probe.get_type() == "probe"
         stanza = self.next_sent()
         assert "yup" in stanza["status"].lower(), stanza
         self.romeo: BaseSession = BaseSession.get_self_or_unique_subclass().from_jid(
@@ -338,7 +339,7 @@ class SlidgeTest(SlixTestPlus):
         )
 
     @classmethod
-    def tearDownClass(cls):
+    def tearDownClass(cls) -> None:
         reset_subclasses()
 
 
@@ -348,7 +349,7 @@ def format_stanza(stanza):
     )
 
 
-def find_subclass(o, parent, base_ok=False):
+def find_subclass(o, parent, base_ok: bool = False):
     try:
         vals = vars(o).values()
     except TypeError:
@@ -366,7 +367,7 @@ def find_subclass(o, parent, base_ok=False):
             raise RuntimeError
 
 
-def reset_subclasses():
+def reset_subclasses() -> None:
     """
     Reset registered subclasses between test classes.
 
@@ -383,7 +384,7 @@ def reset_subclasses():
     # reset_commands()
 
 
-def reset_commands():
+def reset_commands() -> None:
     Command.subclasses = [
         c for c in Command.subclasses if str(c).startswith("<class 'slidge.core")
     ]

slidge/util/types.py

@@ -10,6 +10,7 @@ from typing import (
     IO,
     TYPE_CHECKING,
     Any,
+    AsyncIterator,
     Generic,
     Hashable,
     Literal,
@@ -25,19 +26,15 @@ from slixmpp.types import PresenceShows, PresenceTypes, ResourceDict
 
 if TYPE_CHECKING:
     from ..contact import LegacyContact
-    from ..core.pubsub import PepItem
     from ..core.session import BaseSession
-    from ..group.participant import LegacyMUC, LegacyParticipant
+    from ..group import LegacyMUC
+    from ..group.participant import LegacyParticipant
 
     AnyBaseSession = BaseSession[Any, Any]
 else:
     AnyBaseSession = None
 
 
-class URL(str):
-    pass
-
-
 LegacyGroupIdType = TypeVar("LegacyGroupIdType", bound=Hashable)
 """
 Type of the unique identifier for groups, usually a str or an int,
@@ -47,18 +44,14 @@ LegacyMessageType = TypeVar("LegacyMessageType", bound=Hashable)
 LegacyThreadType = TypeVar("LegacyThreadType", bound=Hashable)
 LegacyUserIdType = TypeVar("LegacyUserIdType", bound=Hashable)
 
-LegacyContactType = TypeVar("LegacyContactType", bound="LegacyContact")
-LegacyMUCType = TypeVar("LegacyMUCType", bound="LegacyMUC")
+LegacyContactType = TypeVar("LegacyContactType", bound="LegacyContact[Any]")
+LegacyMUCType = TypeVar("LegacyMUCType", bound="LegacyMUC[Any, Any, Any, Any]")
 LegacyParticipantType = TypeVar("LegacyParticipantType", bound="LegacyParticipant")
 
-PepItemType = TypeVar("PepItemType", bound="PepItem")
-
-Recipient = Union["LegacyMUC", "LegacyContact"]
+Recipient = Union["LegacyMUC[Any, Any, Any, Any]", "LegacyContact[Any]"]
 RecipientType = TypeVar("RecipientType", bound=Recipient)
-Sender = Union["LegacyContact", "LegacyParticipant"]
-AvatarType = Union[bytes, str, Path]
+Sender = Union["LegacyContact[Any]", "LegacyParticipant"]
 LegacyFileIdType = Union[int, str]
-AvatarIdType = Union[LegacyFileIdType, URL]
 
 ChatState = Literal["active", "composing", "gone", "inactive", "paused"]
 ProcessingHint = Literal["no-store", "markable", "store"]
@@ -79,6 +72,7 @@ MucRole = Literal["visitor", "participant", "moderator", "none"]
 ClientType = Literal[
     "bot", "console", "game", "handheld", "pc", "phone", "sms", "tablet", "web"
 ]
+AttachmentDisposition = Literal["attachment", "inline"]
 
 
 @dataclass
@@ -116,21 +110,26 @@ class LegacyAttachment:
     path: Optional[Union[Path, str]] = None
     name: Optional[Union[str]] = None
     stream: Optional[IO[bytes]] = None
+    aio_stream: Optional[AsyncIterator[bytes]] = None
     data: Optional[bytes] = None
     content_type: Optional[str] = None
     legacy_file_id: Optional[Union[str, int]] = None
     url: Optional[str] = None
     caption: Optional[str] = None
+    disposition: Optional[AttachmentDisposition] = None
     """
     A caption for this specific image. For a global caption for a list of attachments,
     use the ``body`` parameter of :meth:`.AttachmentMixin.send_files`
     """
 
-    def __post_init__(self):
-        if not any(
-            x is not None for x in (self.path, self.stream, self.data, self.url)
+    def __post_init__(self) -> None:
+        if all(
+            x is None
+            for x in (self.path, self.stream, self.data, self.url, self.aio_stream)
         ):
             raise TypeError("There is not data in this attachment", self)
+        if isinstance(self.path, str):
+            self.path = Path(self.path)
 
 
 class MucType(IntEnum):
@@ -171,7 +170,7 @@ class LinkPreview(NamedTuple):
 
 
 class Mention(NamedTuple):
-    contact: "LegacyContact"
+    contact: "LegacyContact[Any]"
     start: int
     end: int
 
@@ -207,3 +206,10 @@ class Sticker(NamedTuple):
     path: Path
     content_type: Optional[str]
     hashes: dict[str, str]
+
+
+class Avatar(NamedTuple):
+    path: Optional[Path] = None
+    unique_id: Optional[str | int] = None
+    url: Optional[str] = None
+    data: Optional[bytes] = None

slidge/util/util.py

@@ -7,7 +7,7 @@ from abc import ABCMeta
 from functools import wraps
 from pathlib import Path
 from time import time
-from typing import TYPE_CHECKING, Callable, NamedTuple, Optional, Type, TypeVar
+from typing import TYPE_CHECKING, Any, Callable, NamedTuple, Optional, Type, TypeVar
 
 try:
     import emoji
@@ -34,7 +34,7 @@ except ImportError as e:
     )
 
 
-def fix_suffix(path: Path, mime_type: Optional[str], file_name: Optional[str]):
+def fix_suffix(path: Path, mime_type: Optional[str], file_name: Optional[str]) -> Path:
     guessed = magic.from_file(path, mime=True)
     if guessed == mime_type:
         log.debug("Magic and given MIME match")
@@ -65,9 +65,15 @@ def fix_suffix(path: Path, mime_type: Optional[str], file_name: Optional[str]):
 
 
 class SubclassableOnce(type):
-    TEST_MODE = False  # To allow importing everything, including plugins, during tests
-
-    def __init__(cls, name, bases, dct):
+    # To allow importing everything, including plugins, during tests
+    TEST_MODE: bool = False
+
+    def __init__(
+        cls,
+        name: str,
+        bases: tuple[Type[Any], ...],
+        dct: dict[str, Any],
+    ) -> None:
         for b in bases:
             if type(b) in (SubclassableOnce, ABCSubclassableOnceAtMost):
                 if hasattr(b, "_subclass") and not cls.TEST_MODE:
@@ -84,19 +90,19 @@ class SubclassableOnce(type):
 
         super().__init__(name, bases, dct)
 
-    def get_self_or_unique_subclass(cls):
+    def get_self_or_unique_subclass(cls) -> "SubclassableOnce":
         try:
             return cls.get_unique_subclass()
         except AttributeError:
             return cls
 
-    def get_unique_subclass(cls):
+    def get_unique_subclass(cls) -> "SubclassableOnce":
         r = getattr(cls, "_subclass", None)
         if r is None:
             raise AttributeError("Could not find any subclass", cls)
         return r
 
-    def reset_subclass(cls):
+    def reset_subclass(cls) -> None:
         try:
             log.debug("Resetting subclass of %s", cls)
             delattr(cls, "_subclass")
@@ -156,7 +162,7 @@ ILLEGAL_XML_CHARS_RE = re.compile(XML_ILLEGAL_CHARACTER_REGEX)
 # from https://stackoverflow.com/a/35804945/5902284
 def addLoggingLevel(
     levelName: str = "TRACE", levelNum: int = logging.DEBUG - 5, methodName=None
-):
+) -> None:
     """
     Comprehensively adds a new logging level to the `logging` module and the
     currently configured logging class.
@@ -197,11 +203,11 @@ def addLoggingLevel(
     # This method was inspired by the answers to Stack Overflow post
     # http://stackoverflow.com/q/2183233/2988730, especially
     # http://stackoverflow.com/a/13638084/2988730
-    def logForLevel(self, message, *args, **kwargs):
+    def logForLevel(self, message, *args, **kwargs) -> None:
         if self.isEnabledFor(levelNum):
             self._log(levelNum, message, args, **kwargs)
 
-    def logToRoot(message, *args, **kwargs):
+    def logToRoot(message, *args, **kwargs) -> None:
         logging.log(levelNum, message, *args, **kwargs)
 
     logging.addLevelName(levelNum, levelName)
@@ -211,7 +217,7 @@ def addLoggingLevel(
 
 
 class SlidgeLogger(logging.Logger):
-    def trace(self):
+    def trace(self) -> None:
         pass
 
 
@@ -294,15 +300,6 @@ def replace_mentions(
     return "".join(pieces)
 
 
-def with_session(func):
-    @wraps(func)
-    async def wrapped(self, *args, **kwargs):
-        with self.xmpp.store.session():
-            return await func(self, *args, **kwargs)
-
-    return wrapped
-
-
 def timeit(func):
     @wraps(func)
     async def wrapped(self, *args, **kwargs):
@@ -325,5 +322,12 @@ def strip_leading_emoji(text: str) -> str:
     return text
 
 
-async def noop_coro():
+async def noop_coro() -> None:
     pass
+
+
+def add_quote_prefix(text: str):
+    """
+    Return multi-line text with leading quote marks (i.e. the ">" character).
+    """
+    return "\n".join(("> " + x).strip() for x in text.split("\n")).strip()

{slidge-0.2.11.dist-info → slidge-0.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: slidge
-Version: 0.2.11
+Version: 0.3.0
 Summary: XMPP bridging framework
 Author-email: Nicolas Cedilnik <nicoco@nicoco.fr>
 License-Expression: AGPL-3.0-or-later