slidge-whatsapp 0.2.1__cp311-cp311-manylinux_2_36_x86_64.whl → 0.2.2__cp311-cp311-manylinux_2_36_x86_64.whl

slidge_whatsapp/__init__.py

@@ -13,5 +13,5 @@ def main():
     entrypoint("slidge_whatsapp")
 
 
-__version__ = "0.2.1"
+__version__ = "v0.2.2"
 __all__ = "Gateway", "session", "command", "contact", "config", "group", "main"

slidge_whatsapp/event.go

@@ -2,18 +2,15 @@ package whatsapp
 
 import (
 	// Standard library.
-	"bytes"
 	"context"
 	"fmt"
-	"image/gif"
 	"mime"
 	"strings"
 
 	// Internal packages.
-	"git.sr.ht/~nicoco/slidge-whatsapp/slidge_whatsapp/media"
+	"codeberg.org/slidge/slidge-whatsapp/slidge_whatsapp/media"
 
 	// Third-party libraries.
-	"github.com/h2non/filetype"
 	"go.mau.fi/whatsmeow"
 	"go.mau.fi/whatsmeow/proto/waE2E"
 	"go.mau.fi/whatsmeow/proto/waWeb"
@@ -185,6 +182,21 @@ type Attachment struct {
 	spec *media.Spec // Metadata specific to audio/video files, used in processing.
 }
 
+// GetSpec returns metadata for this attachment, as derived from the underlying attachment data.
+func (a *Attachment) GetSpec(ctx context.Context) (*media.Spec, error) {
+	if a.spec != nil {
+		return a.spec, nil
+	}
+
+	spec, err := media.GetSpec(ctx, a.Data)
+	if err != nil {
+		return nil, err
+	}
+
+	a.spec = spec
+	return a.spec, nil
+}
+
 // PreviewKind represents different ways of previewingadditional data inline with messages.
 type PreviewKind int
 
@@ -230,10 +242,9 @@ func newMessageEvent(client *whatsmeow.Client, evt *events.Message) (EventKind,
 		IsCarbon:  evt.Info.IsFromMe,
 	}
 
-	// Handle Broadcasts and Status Updates; currently, only non-carbon, non-status broadcast
-	// messages are handled as plain messages, as support for analogues is lacking in the XMPP
-	// world.
 	if evt.Info.Chat.Server == types.BroadcastServer {
+		// Handle non-carbon, non-status broadcast messages as plain messages; support for other
+		// types is lacking in the XMPP world.
 		if evt.Info.Chat.User == types.StatusBroadcastJID.User || message.IsCarbon {
 			return EventUnknown, nil
 		}
@@ -427,7 +438,7 @@ func getMessageAttachments(client *whatsmeow.Client, message *waE2E.Message) ([]
 const (
 	// The MIME type used by voice messages on WhatsApp.
 	voiceMessageMIME = string(media.TypeOgg) + "; codecs=opus"
-	// the MIME type used by animated images on WhatsApp.
+	// The MIME type used by animated images on WhatsApp.
 	animatedImageMIME = "image/gif"
 
 	// The maximum image attachment size we'll attempt to process in any way, in bytes.
@@ -437,10 +448,6 @@ const (
 
 	// The maximum number of samples to return in media waveforms.
 	maxWaveformSamples = 64
-
-	// Default thumbnail width in pixels.
-	defaultThumbnailWidth = 100
-	previewThumbnailWidth = 250
 )
 
 var (
@@ -476,6 +483,18 @@ var (
 		MIME:         media.TypeJPEG,
 		ImageQuality: 85,
 	}
+
+	// Default target specifications for default and preview-size thumbnails.
+	defaultThumbnailSpec = media.Spec{
+		MIME:          media.TypeJPEG,
+		ImageWidth:    100,
+		StripMetadata: true,
+	}
+	previewThumbnailSpec = media.Spec{
+		MIME:          media.TypeJPEG,
+		ImageWidth:    250,
+		StripMetadata: true,
+	}
 )
 
 // ConvertAttachment attempts to process a given attachment from a less-supported type to a
@@ -488,11 +507,11 @@ var (
 // If the input MIME type is unknown, or conversion is impossible, the given attachment is not
 // changed.
 func convertAttachment(attach *Attachment) error {
-	var detectedMIME string
-	if t, _ := filetype.Match(attach.Data); t != filetype.Unknown {
-		detectedMIME = t.MIME.Value
+	var detectedMIME media.MIMEType
+	if t := media.DetectMIMEType(attach.Data); t != media.TypeUnknown {
+		detectedMIME = t
 		if attach.MIME == "" || attach.MIME == "application/octet-stream" {
-			attach.MIME = detectedMIME
+			attach.MIME = string(detectedMIME)
 		}
 	}
 
@@ -500,41 +519,32 @@ func convertAttachment(attach *Attachment) error {
 	var ctx = context.Background()
 
 	switch detectedMIME {
-	case "image/png", "image/webp":
+	case media.TypePNG, media.TypeWebP:
 		// Convert common image formats to JPEG for inline preview.
 		if len(attach.Data) > maxConvertImageSize {
 			return fmt.Errorf("attachment size %d exceeds maximum of %d", len(attach.Data), maxConvertImageSize)
 		}
 
 		spec = imageMessageSpec
-	case "image/gif":
-		// Convert animated GIFs to MP4, as required by WhatsApp.
+	case media.TypeGIF:
+		// Convert GIFs to JPEG or MP4, if animated, as required by WhatsApp.
 		if len(attach.Data) > maxConvertImageSize {
 			return fmt.Errorf("attachment size %d exceeds maximum of %d", len(attach.Data), maxConvertImageSize)
 		}
 
-		img, err := gif.DecodeAll(bytes.NewReader(attach.Data))
-		if err != nil {
-			return fmt.Errorf("unable to decode GIF attachment")
-		} else if len(img.Image) == 1 {
-			spec = imageMessageSpec
-		} else {
+		spec = imageMessageSpec
+		if s, err := attach.GetSpec(ctx); err == nil && s.ImageFrameRate > 0 {
 			spec = videoMessageSpec
-			var t float64
-			for d := range img.Delay {
-				t += float64(d) / 100
-			}
-			spec.ImageFrameRate = int(float64(len(img.Image)) / t)
+			spec.ImageFrameRate = s.ImageFrameRate
 		}
-	case "audio/m4a", "audio/mp4":
+	case media.TypeM4A:
 		if len(attach.Data) > maxConvertAudioVideoSize {
 			return fmt.Errorf("attachment size %d exceeds maximum of %d", len(attach.Data), maxConvertAudioVideoSize)
 		}
 
 		spec = voiceMessageSpec
 
-		if s, err := media.GetSpec(ctx, attach.Data); err == nil {
-			attach.spec = s
+		if s, err := attach.GetSpec(ctx); err == nil {
 			if s.AudioCodec == "alac" {
 				// Don't attempt to process lossless files at all, as it's assumed that the sender
 				// wants to retain these characteristics. Since WhatsApp will try (and likely fail)
@@ -543,29 +553,27 @@ func convertAttachment(attach *Attachment) error {
 				return nil
 			}
 		}
-	case "audio/ogg":
+	case media.TypeOgg:
 		if len(attach.Data) > maxConvertAudioVideoSize {
 			return fmt.Errorf("attachment size %d exceeds maximum of %d", len(attach.Data), maxConvertAudioVideoSize)
 		}
 
 		spec = audioMessageSpec
-		if s, err := media.GetSpec(ctx, attach.Data); err == nil {
-			attach.spec = s
+		if s, err := attach.GetSpec(ctx); err == nil {
 			if s.AudioCodec == "opus" {
 				// Assume that Opus-encoded Ogg files are meant to be voice messages, and re-encode
 				// them as such for WhatsApp.
 				spec = voiceMessageSpec
 			}
 		}
-	case "video/mp4", "video/webm":
+	case media.TypeMP4, media.TypeWebM:
 		if len(attach.Data) > maxConvertAudioVideoSize {
 			return fmt.Errorf("attachment size %d exceeds maximum of %d", len(attach.Data), maxConvertAudioVideoSize)
 		}
 
 		spec = videoMessageSpec
 
-		if s, err := media.GetSpec(ctx, attach.Data); err == nil {
-			attach.spec = s
+		if s, err := attach.GetSpec(ctx); err == nil {
 			// Try to see if there's a video stream for ostensibly video-related MIME types, as
 			// these are some times misdetected as such.
 			if s.VideoWidth == 0 && s.VideoHeight == 0 && s.AudioSampleRate > 0 && s.Duration > 0 {
@@ -638,18 +646,17 @@ func uploadAttachment(client *whatsmeow.Client, attach *Attachment) (*waE2E.Mess
 				FileLength:    ptrTo(uint64(len(attach.Data))),
 			},
 		}
-		t, err := media.Convert(ctx, attach.Data, &media.Spec{MIME: media.TypeJPEG, ImageWidth: defaultThumbnailWidth})
+		t, err := media.Convert(ctx, attach.Data, &defaultThumbnailSpec)
 		if err != nil {
 			client.Log.Warnf("failed generating attachment thumbnail: %s", err)
 		} else {
 			message.ImageMessage.JPEGThumbnail = t
 		}
 	case whatsmeow.MediaAudio:
-		spec := attach.spec
-		if spec == nil {
-			if spec, err = media.GetSpec(ctx, attach.Data); err != nil {
-				client.Log.Warnf("failed fetching attachment metadata: %s", err)
-			}
+		spec, err := attach.GetSpec(ctx)
+		if err != nil {
+			client.Log.Warnf("failed fetching attachment metadata: %s", err)
+			spec = &media.Spec{}
 		}
 		message = &waE2E.Message{
 			AudioMessage: &waE2E.AudioMessage{
@@ -675,11 +682,10 @@ func uploadAttachment(client *whatsmeow.Client, attach *Attachment) (*waE2E.Mess
 			}
 		}
 	case whatsmeow.MediaVideo:
-		spec := attach.spec
-		if spec == nil {
-			if spec, err = media.GetSpec(ctx, attach.Data); err != nil {
-				client.Log.Warnf("failed fetching attachment metadata: %s", err)
-			}
+		spec, err := attach.GetSpec(ctx)
+		if err != nil {
+			client.Log.Warnf("failed fetching attachment metadata: %s", err)
+			spec = &media.Spec{}
 		}
 		message = &waE2E.Message{
 			VideoMessage: &waE2E.VideoMessage{
@@ -695,7 +701,7 @@ func uploadAttachment(client *whatsmeow.Client, attach *Attachment) (*waE2E.Mess
 				Height:        ptrTo(uint32(spec.VideoHeight)),
 			},
 		}
-		t, err := media.GetThumbnail(ctx, attach.Data, defaultThumbnailWidth, 0)
+		t, err := media.Convert(ctx, attach.Data, &defaultThumbnailSpec)
 		if err != nil {
 			client.Log.Warnf("failed generating attachment thumbnail: %s", err)
 		} else {
@@ -715,7 +721,22 @@ func uploadAttachment(client *whatsmeow.Client, attach *Attachment) (*waE2E.Mess
 				FileSHA256:    upload.FileSHA256,
 				FileLength:    ptrTo(uint64(len(attach.Data))),
 				FileName:      &attach.Filename,
-			}}
+			},
+		}
+		switch media.MIMEType(attach.MIME) {
+		case media.TypePDF:
+			if spec, err := attach.GetSpec(ctx); err != nil {
+				client.Log.Warnf("failed fetching attachment metadata: %s", err)
+			} else {
+				message.DocumentMessage.PageCount = ptrTo(uint32(spec.DocumentPage))
+			}
+			t, err := media.Convert(ctx, attach.Data, &previewThumbnailSpec)
+			if err != nil {
+				client.Log.Warnf("failed generating attachment thumbnail: %s", err)
+			} else {
+				message.DocumentMessage.JPEGThumbnail = t
+			}
+		}
 	}
 
 	return message, nil
@@ -992,11 +1013,27 @@ type GroupSubject struct {
 type GroupParticipantAction int
 
 const (
-	GroupParticipantActionAdd    GroupParticipantAction = iota // Default action; add participant to list.
-	GroupParticipantActionUpdate                               // Update existing participant information.
-	GroupParticipantActionRemove                               // Remove participant from list, if existing.
+	GroupParticipantActionAdd     GroupParticipantAction = iota // Default action; add participant to list.
+	GroupParticipantActionRemove                                // Remove participant from list, if existing.
+	GroupParticipantActionPromote                               // Make group member into administrator.
+	GroupParticipantActionDemote                                // Make group administrator into member.
 )
 
+// ToParticipantChange converts our public [GroupParticipantAction] to the internal [ParticipantChange]
+// representation.
+func (a GroupParticipantAction) toParticipantChange() whatsmeow.ParticipantChange {
+	switch a {
+	case GroupParticipantActionRemove:
+		return whatsmeow.ParticipantChangeRemove
+	case GroupParticipantActionPromote:
+		return whatsmeow.ParticipantChangePromote
+	case GroupParticipantActionDemote:
+		return whatsmeow.ParticipantChangeDemote
+	default:
+		return whatsmeow.ParticipantChangeAdd
+	}
+}
+
 // 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
 // in WhatsApp.
@@ -1006,6 +1043,25 @@ type GroupParticipant struct {
 	Action      GroupParticipantAction // The specific action to take for this participant; typically to add.
 }
 
+// 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 {
+		return GroupParticipant{}
+	}
+	var affiliation = GroupAffiliationNone
+	if p.IsSuperAdmin {
+		affiliation = GroupAffiliationOwner
+	} else if p.IsAdmin {
+		affiliation = GroupAffiliationAdmin
+	}
+	return GroupParticipant{
+		JID:         p.JID.ToNonAD().String(),
+		Affiliation: affiliation,
+	}
+}
+
 // 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.
@@ -1036,14 +1092,14 @@ func newGroupEvent(evt *events.GroupInfo) (EventKind, *EventPayload) {
 	for _, p := range evt.Promote {
 		group.Participants = append(group.Participants, GroupParticipant{
 			JID:         p.ToNonAD().String(),
-			Action:      GroupParticipantActionUpdate,
+			Action:      GroupParticipantActionPromote,
 			Affiliation: GroupAffiliationAdmin,
 		})
 	}
 	for _, p := range evt.Demote {
 		group.Participants = append(group.Participants, GroupParticipant{
 			JID:         p.ToNonAD().String(),
-			Action:      GroupParticipantActionUpdate,
+			Action:      GroupParticipantActionDemote,
 			Affiliation: GroupAffiliationNone,
 		})
 	}
@@ -1055,20 +1111,12 @@ func newGroupEvent(evt *events.GroupInfo) (EventKind, *EventPayload) {
 // be called when partial data is to be returned.
 func newGroup(client *whatsmeow.Client, info *types.GroupInfo) Group {
 	var participants []GroupParticipant
-	for _, p := range info.Participants {
-		if p.Error > 0 {
+	for i := range info.Participants {
+		p := newGroupParticipant(info.Participants[i])
+		if p.JID == "" {
 			continue
 		}
-		var affiliation = GroupAffiliationNone
-		if p.IsSuperAdmin {
-			affiliation = GroupAffiliationOwner
-		} else if p.IsAdmin {
-			affiliation = GroupAffiliationAdmin
-		}
-		participants = append(participants, GroupParticipant{
-			JID:         p.JID.ToNonAD().String(),
-			Affiliation: affiliation,
-		})
+		participants = append(participants, p)
 	}
 	return Group{
 		JID:  info.JID.ToNonAD().String(),

slidge_whatsapp/gateway.go

@@ -8,7 +8,7 @@ import (
 	"runtime"
 
 	// Internal packages.
-	"git.sr.ht/~nicoco/slidge-whatsapp/slidge_whatsapp/media"
+	"codeberg.org/slidge/slidge-whatsapp/slidge_whatsapp/media"
 
 	// Third-party libraries.
 	_ "github.com/mattn/go-sqlite3"