slidge-whatsapp 0.2.6__cp313-cp313-manylinux_2_36_aarch64.whl → 0.3.0b0__cp313-cp313-manylinux_2_36_aarch64.whl

slidge_whatsapp/contact.py

@@ -2,6 +2,7 @@ from datetime import datetime, timezone
 from typing import TYPE_CHECKING
 
 from slidge import LegacyContact, LegacyRoster
+from slidge.util.types import Avatar
 from slixmpp.exceptions import XMPPError
 
 from . import config
@@ -28,6 +29,12 @@ class Contact(LegacyContact[str]):
         else:
             self.online(last_seen=last_seen)
 
+    async def update_info(self) -> None:
+        if whatsapp.IsAnonymousJID(self.legacy_id):
+            self.log.error(
+                "Contact for anonymous participant added: %s", self.legacy_id
+            )
+
 
 class Roster(LegacyRoster[str, Contact]):
     session: "Session"
@@ -54,9 +61,12 @@ class Roster(LegacyRoster[str, Contact]):
         contact.name = data.Name
         contact.is_friend = True
         try:
-            avatar = self.session.whatsapp.GetAvatar(data.JID, contact.avatar or "")
-            if avatar.URL and contact.avatar != avatar.ID:
-                await contact.set_avatar(avatar.URL, avatar.ID)
+            unique_id = ""
+            if contact.avatar is not None:
+                unique_id = contact.avatar.unique_id or ""
+            avatar = self.session.whatsapp.GetAvatar(data.JID, unique_id)
+            if avatar.URL and unique_id != avatar.ID:
+                await contact.set_avatar(Avatar(url=avatar.URL, unique_id=avatar.ID))
             elif avatar.URL == "" and avatar.ID == "":
                 await contact.set_avatar(None)
         except RuntimeError as err:

slidge_whatsapp/event.go

@@ -46,6 +46,7 @@ type EventPayload struct {
 	QRCode       string
 	PairDeviceID string
 	Connect      Connect
+	LoggedOut    LoggedOut
 	Contact      Contact
 	Presence     Presence
 	Message      Message
@@ -66,6 +67,11 @@ type Connect struct {
 	Error string // The connection error, if any.
 }
 
+// LoggedOut repreents event data related to an explicit or implicit log-out event.
+type LoggedOut struct {
+	Reason string // The human-readable reason for logging out, if any.
+}
+
 // A Avatar represents a small image set for a Contact or Group.
 type Avatar struct {
 	ID  string // The unique ID for this avatar, used for persistent caching.
@@ -82,10 +88,25 @@ type Contact struct {
 // NewContactEvent returns event data meant for [Session.propagateEvent] for the contact information
 // given. Unknown or invalid contact information will return an [EventUnknown] event with nil data.
 func newContactEvent(jid types.JID, info types.ContactInfo) (EventKind, *EventPayload) {
-	var contact = Contact{
-		JID: jid.ToNonAD().String(),
+	contact := newContact(jid, info)
+	if contact.JID == "" {
+		return EventUnknown, nil
 	}
 
+	return EventContact, &EventPayload{Contact: contact}
+}
+
+// NewContact returns a concrete [Contact] instance for the JID and additional information given.
+// In cases where a valid contact can't be returned, [Contact.JID] will be left empty.
+func newContact(jid types.JID, info types.ContactInfo) Contact {
+	// Don't instantiate hidden contacts, as these are better handled as group participants
+	if jid.Server == types.HiddenUserServer {
+		return Contact{}
+	}
+
+	// Find valid contact name from list of alternatives, or return empty contact if none could
+	// be found.
+	var contact = Contact{JID: jid.ToNonAD().String()}
 	for _, n := range []string{info.FullName, info.FirstName, info.BusinessName, info.PushName} {
 		if n != "" {
 			contact.Name = n
@@ -93,12 +114,11 @@ func newContactEvent(jid types.JID, info types.ContactInfo) (EventKind, *EventPa
 		}
 	}
 
-	// Don't attempt to synchronize contacts with no user-readable name.
 	if contact.Name == "" {
-		return EventUnknown, nil
+		return Contact{}
 	}
 
-	return EventContact, &EventPayload{Contact: contact}
+	return contact
 }
 
 // PresenceKind represents the different kinds of activity states possible in WhatsApp.
@@ -169,9 +189,11 @@ type Message struct {
 	Location    Location     // The location metadata for messages, if any.
 	Poll        Poll         // The multiple-choice poll contained in the message, if any.
 	Album       Album        // The image album message, if any.
+	GroupInvite Group        // Group information for the invite group included in this message, if any.
 	MentionJIDs []string     // A list of JIDs mentioned in this message, if any.
 	Receipts    []Receipt    // The receipt statuses for the message, typically provided alongside historical messages.
 	Reactions   []Message    // Reactions attached to message, typically provided alongside historical messages.
+	IsHistory   bool         // Whether or not the message is derived from message history.
 }
 
 // A Attachment represents additional binary data (e.g. images, videos, documents) provided alongside
@@ -253,14 +275,13 @@ type Album struct {
 
 // NewMessageEvent returns event data meant for [Session.propagateEvent] for the primive message
 // event given. Unknown or invalid messages will return an [EventUnknown] event with nil data.
-func newMessageEvent(client *whatsmeow.Client, evt *events.Message) (EventKind, *EventPayload) {
+func newMessageEvent(ctx context.Context, client *whatsmeow.Client, evt *events.Message) (EventKind, *EventPayload) {
 	// Set basic data for message, to be potentially amended depending on the concrete version of
 	// the underlying message.
-	var ctx = context.Background()
 	var message = Message{
 		Kind:      MessagePlain,
 		ID:        evt.Info.ID,
-		JID:       evt.Info.Sender.ToNonAD().String(),
+		JID:       getPreferredJID(ctx, client, evt.Info.Sender, evt.Info.SenderAlt).ToNonAD().String(),
 		Body:      evt.Message.GetConversation(),
 		Timestamp: evt.Info.Timestamp.Unix(),
 		IsCarbon:  evt.Info.IsFromMe,
@@ -378,7 +399,18 @@ func newMessageEvent(client *whatsmeow.Client, evt *events.Message) (EventKind,
 			message.Body = e.GetText()
 		}
 
-		message = getMessageWithContext(message, e.GetContextInfo())
+		// Handle group-chat invite link in text message.
+		if code, ok := strings.CutPrefix(e.GetMatchedText(), whatsmeow.InviteLinkPrefix); ok {
+			if info, err := client.GetGroupInfoFromLink(e.GetMatchedText()); err != nil {
+				client.Log.Errorf("Failed getting group info from invite: %s", err)
+			} else if _, err := client.JoinGroupWithLink(code); err != nil {
+				client.Log.Errorf("Failed joining group with invite: %s", err)
+			} else {
+				message.GroupInvite = newGroup(ctx, client, info)
+			}
+		} else {
+			message = getMessageWithContext(message, e.GetContextInfo())
+		}
 	}
 
 	// Ignore obviously invalid messages.
@@ -424,6 +456,7 @@ func getMessageAttachments(ctx context.Context, client *whatsmeow.Client, messag
 		message.GetVideoMessage(),
 		message.GetDocumentMessage(),
 		message.GetStickerMessage(),
+		message.GetPtvMessage(),
 	}
 
 	for _, msg := range kinds {
@@ -462,7 +495,9 @@ func getMessageAttachments(ctx context.Context, client *whatsmeow.Client, messag
 		// Convert incoming data if a specification has been given, ignoring any errors that occur.
 		if convertSpec != nil {
 			data, err = media.Convert(ctx, a.Data, convertSpec)
-			if err == nil {
+			if err != nil {
+				client.Log.Warnf("failed to convert incoming attachment: %s", err)
+			} else {
 				a.Data, a.MIME = data, string(convertSpec.MIME)
 			}
 		}
@@ -648,6 +683,10 @@ func convertAttachment(ctx context.Context, attach *Attachment) error {
 	}
 
 	attach.Data, attach.MIME = data, string(spec.MIME)
+	if i := strings.LastIndexByte(attach.Filename, '.'); i != -1 {
+		attach.Filename = attach.Filename[:i] + extensionByType(attach.MIME)
+	}
+
 	return nil
 }
 
@@ -669,7 +708,7 @@ var knownMediaTypes = map[string]whatsmeow.MediaType{
 func uploadAttachment(ctx context.Context, client *whatsmeow.Client, attach *Attachment) (*waE2E.Message, error) {
 	var originalMIME = attach.MIME
 	if err := convertAttachment(ctx, attach); err != nil {
-		client.Log.Warnf("failed to auto-convert attachment: %s", err)
+		client.Log.Warnf("failed to convert outgoing attachment: %s", err)
 	}
 
 	mediaType := knownMediaTypes[getBaseMediaType(attach.MIME)]
@@ -831,10 +870,9 @@ func getBaseMediaType(typ string) string {
 //
 // Typically, this will return [EventMessage] events with appropriate [Message] payloads; unknown or
 // invalid messages will return an [EventUnknown] event with nil data.
-func newEventFromHistory(client *whatsmeow.Client, info *waWeb.WebMessageInfo) (EventKind, *EventPayload) {
+func newEventFromHistory(ctx context.Context, client *whatsmeow.Client, info *waWeb.WebMessageInfo) (EventKind, *EventPayload) {
 	// Handle message as group message is remote JID is a group JID in the absence of any other,
 	// specific signal, or don't handle at all if no group JID is found.
-	var ctx = context.Background()
 	var jid = info.GetKey().GetRemoteJID()
 	if j, _ := types.ParseJID(jid); j.Server != types.GroupServer {
 		return EventUnknown, nil
@@ -849,6 +887,7 @@ func newEventFromHistory(client *whatsmeow.Client, info *waWeb.WebMessageInfo) (
 		Body:      info.GetMessage().GetConversation(),
 		Timestamp: int64(info.GetMessageTimestamp()),
 		IsCarbon:  info.GetKey().GetFromMe(),
+		IsHistory: true,
 	}
 
 	if info.Participant != nil {
@@ -1003,10 +1042,10 @@ type Receipt struct {
 
 // NewReceiptEvent returns event data meant for [Session.propagateEvent] for the primive receipt
 // event given. Unknown or invalid receipts will return an [EventUnknown] event with nil data.
-func newReceiptEvent(evt *events.Receipt) (EventKind, *EventPayload) {
+func newReceiptEvent(ctx context.Context, client *whatsmeow.Client, evt *events.Receipt) (EventKind, *EventPayload) {
 	var receipt = Receipt{
 		MessageIDs: slices.Clone(evt.MessageIDs),
-		JID:        evt.Sender.ToNonAD().String(),
+		JID:        getPreferredJID(ctx, client, evt.Sender, evt.SenderAlt).ToNonAD().String(),
 		Timestamp:  evt.Timestamp.Unix(),
 		IsCarbon:   evt.IsFromMe,
 	}
@@ -1053,14 +1092,15 @@ type Group struct {
 	Subject      GroupSubject       // The longer-form, user-defined description for this group.
 	Nickname     string             // Our own nickname in this group-chat.
 	Participants []GroupParticipant // The list of participant contacts for this group, including ourselves.
+	InviteCode   string             // The code for inviting members to this group-chat.
 }
 
 // A GroupSubject represents the user-defined group description and attached metadata thereof, for a
 // given [Group].
 type GroupSubject struct {
-	Subject  string // The user-defined group description.
-	SetAt    int64  // The exact time this group description was set at, as a timestamp.
-	SetByJID string // The JID of the user that set the subject.
+	Subject string // The user-defined group description.
+	SetAt   int64  // The exact time this group description was set at, as a timestamp.
+	SetBy   string // The name of the user that set the subject.
 }
 
 // GroupParticipantAction represents the distinct set of actions that can be taken when encountering
@@ -1090,10 +1130,11 @@ func (a GroupParticipantAction) toParticipantChange() whatsmeow.ParticipantChang
 }
 
 // A GroupParticipant represents a contact who is currently joined in a given group. Participants in
-// WhatsApp can always be derived back to their individual [Contact]; there are no anonymous groups
+// WhatsApp can generally be derived back to their individual [Contact]; there are no anonymous groups
 // in WhatsApp.
 type GroupParticipant struct {
 	JID         string                 // The WhatsApp JID for this participant.
+	Nickname    string                 // The user-set name for this participant, typically only set for anonymous participants.
 	Affiliation GroupAffiliation       // The set of priviledges given to this specific participant.
 	Action      GroupParticipantAction // The specific action to take for this participant; typically to add.
 }
@@ -1101,35 +1142,42 @@ type GroupParticipant struct {
 // NewGroupParticipant returns a [GroupParticipant], filling fields from the internal participant
 // type. This is a no-op if [types.GroupParticipant.Error] is non-zero, and other fields may only
 // be set optionally.
-func newGroupParticipant(p types.GroupParticipant) GroupParticipant {
-	if p.Error > 0 {
+func newGroupParticipant(ctx context.Context, client *whatsmeow.Client, participant types.GroupParticipant) GroupParticipant {
+	if participant.Error > 0 {
 		return GroupParticipant{}
 	}
-	var affiliation = GroupAffiliationNone
-	if p.IsSuperAdmin {
-		affiliation = GroupAffiliationOwner
-	} else if p.IsAdmin {
-		affiliation = GroupAffiliationAdmin
+	var p = GroupParticipant{
+		JID: participant.JID.ToNonAD().String(),
 	}
-	return GroupParticipant{
-		JID:         p.JID.ToNonAD().String(),
-		Affiliation: affiliation,
+	if participant.IsSuperAdmin {
+		p.Affiliation = GroupAffiliationOwner
+	} else if participant.IsAdmin {
+		p.Affiliation = GroupAffiliationAdmin
 	}
+	if IsAnonymousJID(p.JID) {
+		if c, err := client.Store.Contacts.GetContact(ctx, participant.JID); err == nil {
+			p.Nickname = c.PushName
+		}
+	}
+	return p
 }
 
 // NewGroupEvent returns event data meant for [Session.propagateEvent] for the primive group event
 // given. Group data returned by this function can be partial, and callers should take care to only
 // handle non-empty values.
-func newGroupEvent(evt *events.GroupInfo) (EventKind, *EventPayload) {
+func newGroupEvent(ctx context.Context, client *whatsmeow.Client, evt *events.GroupInfo) (EventKind, *EventPayload) {
 	var group = Group{JID: evt.JID.ToNonAD().String()}
 	if evt.Name != nil {
 		group.Name = evt.Name.Name
 	}
 	if evt.Topic != nil {
+		topicJID := getPreferredJID(ctx, client, evt.Topic.TopicSetBy, evt.Topic.TopicSetByPN)
 		group.Subject = GroupSubject{
-			Subject:  evt.Topic.Topic,
-			SetAt:    evt.Topic.TopicSetAt.Unix(),
-			SetByJID: evt.Topic.TopicSetBy.ToNonAD().String(),
+			Subject: evt.Topic.Topic,
+			SetAt:   evt.Topic.TopicSetAt.Unix(),
+		}
+		if c, err := client.Store.Contacts.GetContact(ctx, topicJID); err == nil {
+			group.Subject.SetBy = c.PushName
 		}
 	}
 	for _, p := range evt.Join {
@@ -1164,26 +1212,32 @@ func newGroupEvent(evt *events.GroupInfo) (EventKind, *EventPayload) {
 // NewGroup returns a concrete [Group] for the primitive data given. This function will generally
 // populate fields with as much data as is available from the remote, and is therefore should not
 // be called when partial data is to be returned.
-func newGroup(client *whatsmeow.Client, info *types.GroupInfo) Group {
+func newGroup(ctx context.Context, client *whatsmeow.Client, info *types.GroupInfo) Group {
 	var participants []GroupParticipant
 	for i := range info.Participants {
-		p := newGroupParticipant(info.Participants[i])
+		p := newGroupParticipant(ctx, client, info.Participants[i])
 		if p.JID == "" {
 			continue
 		}
 		participants = append(participants, p)
 	}
-	return Group{
+
+	var topicJID = getPreferredJID(ctx, client, info.TopicSetBy, info.TopicSetByPN)
+	var group = Group{
 		JID:  info.JID.ToNonAD().String(),
 		Name: info.Name,
 		Subject: GroupSubject{
-			Subject:  info.Topic,
-			SetAt:    info.TopicSetAt.Unix(),
-			SetByJID: info.TopicSetBy.ToNonAD().String(),
+			Subject: info.Topic,
+			SetAt:   info.TopicSetAt.Unix(),
 		},
 		Nickname:     client.Store.PushName,
 		Participants: participants,
 	}
+	if c, err := client.Store.Contacts.GetContact(ctx, topicJID); err == nil {
+		group.Subject.SetBy = c.PushName
+	}
+
+	return group
 }
 
 // CallState represents the state of the call to synchronize with.
@@ -1228,3 +1282,25 @@ func newCallEvent(state CallState, meta types.BasicCallMeta) (EventKind, *EventP
 		Timestamp: meta.Timestamp.Unix(),
 	}}
 }
+
+// GetPreferredJID returns one of the [type.JID] values for the given senders, preferring the first
+// non-empty, non-hidden sender; if none are found, mappings from LID to JID are tried, or otherwise,
+// the first JID given is returned.
+func getPreferredJID(ctx context.Context, client *whatsmeow.Client, def types.JID, alt ...types.JID) types.JID {
+	var jids = append([]types.JID{def}, alt...)
+	for _, s := range jids {
+		if !s.IsEmpty() && s.Server != types.HiddenUserServer {
+			return s
+		}
+	}
+
+	for _, s := range jids {
+		if !s.IsEmpty() && s.Server == types.HiddenUserServer {
+			if p, err := client.Store.LIDs.GetPNForLID(ctx, s); err == nil {
+				return p
+			}
+		}
+	}
+
+	return def
+}

slidge_whatsapp/gateway.go

@@ -3,9 +3,6 @@ package whatsapp
 import (
 	// Standard library.
 	"context"
-	"fmt"
-	"log/slog"
-	"os"
 	"runtime"
 
 	// Internal packages.
@@ -40,6 +37,12 @@ func (d LinkedDevice) JID() types.JID {
 	return jid
 }
 
+// IsAnonymousJID returns true if the JID given is not addressible, that is, if it's actually a LID.
+func IsAnonymousJID(id string) bool {
+	jid, _ := types.ParseJID(id)
+	return jid.Server == types.HiddenUserServer
+}
+
 // A Gateway represents a persistent process for establishing individual sessions between linked
 // devices and WhatsApp.
 type Gateway struct {
@@ -63,13 +66,7 @@ func NewGateway() *Gateway {
 // Init performs initialization procedures for the Gateway, and is expected to be run before any
 // calls to [Gateway.Session].
 func (w *Gateway) Init() error {
-	w.logger = logger{
-		module: "Slidge",
-		logger: slog.New(
-			slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{Level: logLevel(w.LogLevel)}),
-		),
-	}
-
+	w.logger = walog.Stdout("slidge", w.LogLevel, false)
 	container, err := sqlstore.New(context.Background(), "sqlite3", w.DBPath, w.logger)
 	if err != nil {
 		return err
@@ -130,56 +127,3 @@ func (w *Gateway) CleanupSession(device LinkedDevice) error {
 
 	return nil
 }
-
-// A LogLevel represents a mapping between Python standard logging levels and Go standard logging
-// levels.
-type logLevel string
-
-var _ slog.Leveler = logLevel("")
-
-// Level returns the Go equivalent logging level for the Python logging level represented.
-func (l logLevel) Level() slog.Level {
-	switch l {
-	case "FATAL", "CRITICAL", "ERROR":
-		return slog.LevelError
-	case "WARN", "WARNING":
-		return slog.LevelWarn
-	case "DEBUG":
-		return slog.LevelDebug
-	default:
-		return slog.LevelInfo
-	}
-}
-
-// A Logger represents a mapping between a WhatsMeow logger and Go standard logging functions.
-type logger struct {
-	module string
-	logger *slog.Logger
-}
-
-var _ walog.Logger = logger{}
-
-// Errorf handles the given message as representing a (typically) fatal error.
-func (l logger) Errorf(msg string, args ...any) {
-	l.logger.Error(fmt.Sprintf(msg, args...))
-}
-
-// Warn handles the given message as representing a non-fatal error or warning thereof.
-func (l logger) Warnf(msg string, args ...any) {
-	l.logger.Warn(fmt.Sprintf(msg, args...))
-}
-
-// Infof handles the given message as representing an informational notice.
-func (l logger) Infof(msg string, args ...any) {
-	l.logger.Info(fmt.Sprintf(msg, args...))
-}
-
-// Debugf handles the given message as representing an internal-only debug message.
-func (l logger) Debugf(msg string, args ...any) {
-	l.logger.Debug(fmt.Sprintf(msg, args...))
-}
-
-// Sub is a no-op and will return the receiver itself.
-func (l logger) Sub(module string) walog.Logger {
-	return logger{logger: l.logger.With(slog.String("module", l.module+"."+module))}
-}

slidge_whatsapp/gateway.py

@@ -2,7 +2,7 @@ from logging import getLevelName, getLogger
 from pathlib import Path
 from typing import TYPE_CHECKING
 
-from slidge import BaseGateway, FormField, GatewayUser, global_config
+from slidge import BaseGateway, FormField, global_config
 
 from . import config
 from .generated import whatsapp
@@ -62,13 +62,12 @@ class Gateway(BaseGateway):
         """
         pass
 
-    async def unregister(self, user: GatewayUser):
+    async def unregister(self, session: "Session"):  # type:ignore[override]
         """
         Logout from the active WhatsApp session. This will also force a remote log-out, and thus
         require pairing on next login. For simply disconnecting the active session, look at the
         :meth:`.Session.disconnect` function.
         """
-        session: "Session" = self.get_session_from_user(user)  # type:ignore
         session.whatsapp.Logout()
         try:
             device_id = session.user.legacy_module_data["device_id"]