slidge-whatsapp 0.2.7__cp312-cp312-manylinux_2_36_aarch64.whl → 0.3.0b0__cp312-cp312-manylinux_2_36_aarch64.whl

slidge_whatsapp/group.py

@@ -4,7 +4,7 @@ from typing import TYPE_CHECKING, AsyncIterator, Optional
 
 from slidge.group import LegacyBookmarks, LegacyMUC, LegacyParticipant, MucType
 from slidge.util.archive_msg import HistoryMessage
-from slidge.util.types import Hat, HoleBound, Mention, MucAffiliation
+from slidge.util.types import Avatar, Hat, HoleBound, Mention, MucAffiliation
 from slixmpp.exceptions import XMPPError
 
 from .generated import go, whatsapp
@@ -28,9 +28,12 @@ class MUC(LegacyMUC[str, str, Participant, str]):
 
     async def update_info(self):
         try:
-            avatar = self.session.whatsapp.GetAvatar(self.legacy_id, self.avatar or "")
-            if avatar.URL and self.avatar != avatar.ID:
-                await self.set_avatar(avatar.URL, avatar.ID)
+            unique_id = ""
+            if self.avatar is not None:
+                unique_id = self.avatar.unique_id or ""  # type:ignore[assignment]
+            avatar = self.session.whatsapp.GetAvatar(self.legacy_id, unique_id)
+            if avatar.URL and unique_id != avatar.ID:
+                await self.set_avatar(Avatar(url=avatar.URL, unique_id=avatar.ID))
             elif avatar.URL == "" and avatar.ID == "":
                 await self.set_avatar(None)
         except RuntimeError as err:
@@ -60,9 +63,16 @@ class MUC(LegacyMUC[str, str, Participant, str]):
         self.session.whatsapp.RequestMessageHistory(self.legacy_id, oldest_message)
 
     def get_message_sender(self, legacy_msg_id: str):
-        assert self.pk is not None
-        stored = self.xmpp.store.mam.get_by_legacy_id(self.pk, legacy_msg_id)
-        if stored is None:
+        with self.xmpp.store.session() as orm:
+            try:
+                stored = next(
+                    self.xmpp.store.mam.get_messages(
+                        orm, self.stored.id, ids=[legacy_msg_id]
+                    )
+                )
+            except StopIteration:
+                stored = None
+        if not stored:
             raise XMPPError("internal-server-error", "Unable to find message sender")
         msg = HistoryMessage(stored.stanza)
         occupant_id = msg.stanza["occupant-id"]["id"]
@@ -87,17 +97,13 @@ class MUC(LegacyMUC[str, str, Participant, str]):
             if info.Subject.SetAt:
                 set_at = datetime.fromtimestamp(info.Subject.SetAt, tz=timezone.utc)
                 self.subject_date = set_at
-            if info.Subject.SetByJID:
-                participant = await self.get_participant_by_legacy_id(
-                    info.Subject.SetByJID
-                )
-                if name := participant.nickname:
-                    self.subject_setter = name
+            if info.Subject.SetBy:
+                self.subject_setter = info.Subject.SetBy
         self.session.whatsapp_participants[self.legacy_id] = info.Participants
         self.n_participants = len(info.Participants)
         # Since whatsmeow does always emit a whatsapp.Group event even for participant changes,
         # we need to do that to actually update the participant list.
-        if self._participants_filled:
+        if self.participants_filled:
             async for _ in self.fill_participants():
                 pass
 
@@ -109,7 +115,12 @@ class MUC(LegacyMUC[str, str, Participant, str]):
             self.log.warning("No participants!")
             return
         for data in participants:
-            participant = await self.get_participant_by_legacy_id(data.JID)
+            if whatsapp.IsAnonymousJID(data.JID):
+                participant = await self.get_participant(data.JID)
+                if data.Nickname:
+                    participant.nickname = data.Nickname
+            else:
+                participant = await self.get_participant_by_legacy_id(data.JID)
             if data.Action == whatsapp.GroupParticipantActionRemove:
                 self.remove_participant(participant)
             else:
@@ -135,7 +146,7 @@ class MUC(LegacyMUC[str, str, Participant, str]):
             t,
             participants=(
                 {
-                    p.contact.jid_username: p.nickname
+                    p.contact.jid.username: p.nickname
                     async for p in self.get_participants()
                     if p.contact is not None  # should not happen
                 }
@@ -171,16 +182,14 @@ class MUC(LegacyMUC[str, str, Participant, str]):
         reason: Optional[str],
         nickname: Optional[str],
     ):
-        assert contact.contact_pk is not None
-        assert self.pk is not None
         if affiliation == "member":
-            if (
-                self.xmpp.store.participants.get_by_contact(self.pk, contact.contact_pk)
-                is not None
-            ):
-                action = whatsapp.GroupParticipantActionDemote
-            else:
+            participant = await self.get_participant_by_contact(contact, create=False)
+            if participant is None or participant.affiliation in ("outcast", "none"):
                 action = whatsapp.GroupParticipantActionAdd
+            elif participant.affiliation == "member":
+                return
+            else:
+                action = whatsapp.GroupParticipantActionDemote
         elif affiliation == "admin":
             action = whatsapp.GroupParticipantActionPromote
         elif affiliation == "outcast" or affiliation == "none":
@@ -232,12 +241,7 @@ class Bookmarks(LegacyBookmarks[str, MUC]):
             local_part.removeprefix("#") + "@" + whatsapp.DefaultGroupServer
         )
 
-        if (
-            self.xmpp.store.rooms.get_by_legacy_id(
-                self.session.user_pk, whatsapp_group_id
-            )
-            is None
-        ):
+        if not await self.by_legacy_id(whatsapp_group_id, create=False):
             raise XMPPError("item-not-found", f"No group found for {whatsapp_group_id}")
 
         return whatsapp_group_id

slidge_whatsapp/media/media.go

@@ -334,7 +334,7 @@ func processImage(img image.Image, spec *Spec) ([]byte, error) {
 			o.Quality = jpeg.DefaultQuality
 		}
 
-		err = jpeg.Encode(&buf, img, nil)
+		err = jpeg.Encode(&buf, img, &o)
 	case TypePNG:
 		err = png.Encode(&buf, img)
 	}

slidge_whatsapp/session.go

@@ -4,6 +4,7 @@ import (
 	// Standard library.
 	"bytes"
 	"context"
+	"encoding/json"
 	"errors"
 	"fmt"
 	"image/jpeg"
@@ -452,12 +453,16 @@ func (s *Session) GetContacts(refresh bool) ([]Contact, error) {
 
 	var contacts []Contact
 	for jid, info := range data {
+		c := newContact(jid, info)
+		if c.JID == "" {
+			continue
+		}
+
 		if err = s.client.SubscribePresence(jid); err != nil {
 			s.gateway.logger.Warnf("Failed to subscribe to presence for %s", jid)
 		}
 
-		_, c := newContactEvent(jid, info)
-		contacts = append(contacts, c.Contact)
+		contacts = append(contacts, c)
 	}
 
 	return contacts, nil
@@ -466,6 +471,7 @@ func (s *Session) GetContacts(refresh bool) ([]Contact, error) {
 // GetGroups returns a list of all group-chats currently joined in WhatsApp, along with additional
 // information on present participants.
 func (s *Session) GetGroups() ([]Group, error) {
+	var ctx = context.Background()
 	if s.client == nil || s.client.Store.ID == nil {
 		return nil, fmt.Errorf("cannot get groups for unauthenticated session")
 	}
@@ -477,7 +483,7 @@ func (s *Session) GetGroups() ([]Group, error) {
 
 	var groups []Group
 	for _, info := range data {
-		groups = append(groups, newGroup(s.client, info))
+		groups = append(groups, newGroup(ctx, s.client, info))
 	}
 
 	return groups, nil
@@ -486,6 +492,7 @@ func (s *Session) GetGroups() ([]Group, error) {
 // CreateGroup attempts to create a new WhatsApp group for the given human-readable name and
 // participant JIDs given.
 func (s *Session) CreateGroup(name string, participants []string) (Group, error) {
+	var ctx = context.Background()
 	if s.client == nil || s.client.Store.ID == nil {
 		return Group{}, fmt.Errorf("cannot create group for unauthenticated session")
 	}
@@ -501,12 +508,12 @@ func (s *Session) CreateGroup(name string, participants []string) (Group, error)
 	}
 
 	req := whatsmeow.ReqCreateGroup{Name: name, Participants: jids}
-	info, err := s.client.CreateGroup(req)
+	info, err := s.client.CreateGroup(ctx, req)
 	if err != nil {
 		return Group{}, fmt.Errorf("could not create group: %s", err)
 	}
 
-	return newGroup(s.client, info), nil
+	return newGroup(ctx, s.client, info), nil
 }
 
 // LeaveGroup attempts to remove our own user from the given WhatsApp group, for the JID given.
@@ -647,7 +654,7 @@ func (s *Session) UpdateGroupParticipants(resourceID string, participants []Grou
 			return nil, fmt.Errorf("failed setting group affiliation: %s", err)
 		}
 		for i := range participants {
-			p := newGroupParticipant(participants[i])
+			p := newGroupParticipant(ctx, s.client, participants[i])
 			if p.JID == "" {
 				continue
 			}
@@ -669,9 +676,9 @@ func (s *Session) FindContact(phone string) (Contact, error) {
 	}
 
 	jid := types.NewJID(phone, DefaultUserServer)
-	if c, err := s.client.Store.Contacts.GetContact(ctx, jid); err == nil && c.Found {
-		if _, e := newContactEvent(jid, c); e != nil {
-			return e.Contact, nil
+	if info, err := s.client.Store.Contacts.GetContact(ctx, jid); err == nil && info.Found {
+		if c := newContact(jid, info); c.JID != "" {
+			return c, nil
 		}
 	}
 
@@ -747,7 +754,7 @@ func (s *Session) propagateEvent(kind EventKind, payload *EventPayload) {
 // errors that occur during processing are logged.
 func (s *Session) handleEvent(evt any) {
 	var ctx = context.Background()
-	s.gateway.logger.Debugf("Handling event '%T': %+v", evt, evt)
+	s.gateway.logger.Debugf("Handling event '%T': %+v", evt, jsonStringer{evt})
 
 	switch evt := evt.(type) {
 	case *events.AppStateSyncComplete:
@@ -789,22 +796,22 @@ func (s *Session) handleEvent(evt any) {
 		case waHistorySync.HistorySync_INITIAL_BOOTSTRAP, waHistorySync.HistorySync_RECENT, waHistorySync.HistorySync_ON_DEMAND:
 			for _, c := range evt.Data.GetConversations() {
 				for _, msg := range c.GetMessages() {
-					s.propagateEvent(newEventFromHistory(s.client, msg.GetMessage()))
+					s.propagateEvent(newEventFromHistory(ctx, s.client, msg.GetMessage()))
 				}
 			}
 		}
 	case *events.Message:
-		s.propagateEvent(newMessageEvent(s.client, evt))
+		s.propagateEvent(newMessageEvent(ctx, s.client, evt))
 	case *events.Receipt:
-		s.propagateEvent(newReceiptEvent(evt))
+		s.propagateEvent(newReceiptEvent(ctx, s.client, evt))
 	case *events.Presence:
 		s.propagateEvent(newPresenceEvent(evt))
 	case *events.PushName:
 		s.propagateEvent(newContactEvent(evt.JID, types.ContactInfo{FullName: evt.NewPushName}))
 	case *events.JoinedGroup:
-		s.propagateEvent(EventGroup, &EventPayload{Group: newGroup(s.client, &evt.GroupInfo)})
+		s.propagateEvent(EventGroup, &EventPayload{Group: newGroup(ctx, s.client, &evt.GroupInfo)})
 	case *events.GroupInfo:
-		s.propagateEvent(newGroupEvent(evt))
+		s.propagateEvent(newGroupEvent(ctx, s.client, evt))
 	case *events.ChatPresence:
 		s.propagateEvent(newChatStateEvent(evt))
 	case *events.CallOffer:
@@ -817,7 +824,7 @@ func (s *Session) handleEvent(evt any) {
 			s.gateway.logger.Warnf("Unable to delete local device state on logout: %s", err)
 		}
 		s.client = nil
-		s.propagateEvent(EventLoggedOut, nil)
+		s.propagateEvent(EventLoggedOut, &EventPayload{LoggedOut: LoggedOut{Reason: evt.Reason.String()}})
 	case *events.PairSuccess:
 		if s.client.Store.ID == nil {
 			s.gateway.logger.Errorf("Pairing succeeded, but device ID is missing")
@@ -854,6 +861,16 @@ func (s *Session) handleEvent(evt any) {
 	}
 }
 
+// a JSONStringer is a value that returns a JSON-encoded, multi-line version of itself in calls to
+// [String].
+type jsonStringer struct{ v any }
+
+// String returns a multi-line, indented, JSON representation of the [jsonStringer] value.
+func (j jsonStringer) String() string {
+	buf, _ := json.MarshalIndent(j.v, "", "    ")
+	return string(buf)
+}
+
 // PtrTo returns a pointer to the given value, and is used for convenience when converting between
 // concrete and pointer values without assigning to a variable.
 func ptrTo[T any](t T) *T {

slidge_whatsapp/session.py

@@ -6,10 +6,12 @@ from pathlib import Path
 from re import search
 from typing import Any, Optional, Union, cast
 
+import sqlalchemy
 from aiohttp import ClientSession
 from linkpreview import Link, LinkPreview
 from slidge import BaseSession, FormField, GatewayUser, SearchResult, global_config
 from slidge.contact.roster import ContactIsUser
+from slidge.db.models import ArchivedMessage
 from slidge.util import is_valid_phone_number
 from slidge.util.types import (
     LegacyAttachment,
@@ -157,17 +159,24 @@ class Session(BaseSession[str, Recipient]):
                 )
         elif event == whatsapp.EventLoggedOut:
             self.logged = False
-            self.send_gateway_message(MESSAGE_LOGGED_OUT)
+            message = MESSAGE_LOGGED_OUT
+            if data.LoggedOut.Reason:
+                message += f"\nReason: {data.LoggedOut.Reason}"
+            self.send_gateway_message(message)
             self.send_gateway_status("Logged out", show="away")
         elif event == whatsapp.EventContact:
             contact = await self.contacts.add_whatsapp_contact(data.Contact)
-            if contact is not None:
+            if contact is not None and contact.is_friend:
                 await contact.add_to_roster()
         elif event == whatsapp.EventGroup:
             await self.bookmarks.add_whatsapp_group(data.Group)
         elif event == whatsapp.EventPresence:
-            contact = await self.contacts.by_legacy_id(data.Presence.JID)
-            await contact.update_presence(data.Presence.Kind, data.Presence.LastSeen)
+            if not whatsapp.IsAnonymousJID(data.Presence.JID):
+                contact = await self.contacts.by_legacy_id(data.Presence.JID)
+                if contact is not None:
+                    await contact.update_presence(
+                        data.Presence.Kind, data.Presence.LastSeen
+                    )
         elif event == whatsapp.EventChatState:
             await self.handle_chat_state(data.ChatState)
         elif event == whatsapp.EventReceipt:
@@ -217,12 +226,22 @@ class Session(BaseSession[str, Recipient]):
         """
         contact = await self.__get_contact_or_participant(message.JID, message.GroupJID)
         muc = getattr(contact, "muc", None)
+        # Skip handing message that's already in our message archive.
+        if (
+            muc is not None
+            and message.IsHistory
+            and await self.__is_message_in_archive(message.ID)
+        ):
+            return
         reply_to = await self.__get_reply_to(message, muc)
         message_timestamp = (
             datetime.fromtimestamp(message.Timestamp, tz=timezone.utc)
             if message.Timestamp > 0
             else None
         )
+        if message.GroupInvite.JID:
+            text = f"Received group invite for xmpp:{message.GroupInvite.JID} from {contact.name}, auto-joining..."
+            self.send_gateway_message(text)
         if message.Kind == whatsapp.MessagePlain:
             body = await self.__get_body(message, muc)
             contact.send_text(
@@ -543,15 +562,13 @@ class Session(BaseSession[str, Recipient]):
             items=[{"phone": cast(str, phone), "jid": contact.jid.bare}],
         )
 
-    def message_is_carbon(self, c: Recipient, legacy_msg_id: str):
-        stored: Any
-        if c.is_group:
-            assert isinstance(c, MUC)
-            assert c.pk is not None
-            stored = self.xmpp.store.sent.get_group_xmpp_id(c.pk, legacy_msg_id)
-        else:
-            stored = self.xmpp.store.sent.get_xmpp_id(self.user_pk, legacy_msg_id)
-        return stored is not None
+    def message_is_carbon(self, c: Recipient, legacy_msg_id: str) -> bool:
+        with self.xmpp.store.session() as orm:
+            return bool(
+                self.xmpp.store.id_map.get_xmpp(
+                    orm, c.stored.id, legacy_msg_id, c.is_group
+                )
+            )
 
     def __reset_connected(self):
         if hasattr(self, "_connected") and not self.__connected.done():
@@ -675,6 +692,16 @@ class Session(BaseSession[str, Recipient]):
             Accuracy=int(match.group("acc") or 0),
         )
 
+    async def __is_message_in_archive(self, legacy_msg_id: str) -> bool:
+        with self.xmpp.store.session() as orm:
+            return bool(
+                orm.scalar(
+                    sqlalchemy.exists()
+                    .where(ArchivedMessage.legacy_id == legacy_msg_id)
+                    .select()
+                )
+            )
+
     async def __get_contact_or_participant(
         self, legacy_contact_id: str, legacy_group_jid: str
     ):
@@ -683,7 +710,12 @@ class Session(BaseSession[str, Recipient]):
         """
         if legacy_group_jid:
             muc = await self.bookmarks.by_legacy_id(legacy_group_jid)
-            return await muc.get_participant_by_legacy_id(legacy_contact_id)
+            if whatsapp.IsAnonymousJID(legacy_contact_id):
+                return await muc.get_participant(legacy_contact_id)
+            else:
+                return await muc.get_participant_by_legacy_id(legacy_contact_id)
+        elif whatsapp.IsAnonymousJID(legacy_contact_id):
+            raise ValueError("Contact for anonymous JID")
         else:
             return await self.contacts.by_legacy_id(legacy_contact_id)
 

slidge_whatsapp/vendor/github.com/beeper/argo-go/LICENSE

@@ -0,0 +1,9 @@
+
+
+Copyright 2025 Automattic Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.