slidge-whatsapp 0.2.2__cp311-cp311-manylinux_2_36_aarch64.whl → 0.2.5__cp311-cp311-manylinux_2_36_aarch64.whl

slidge_whatsapp/vendor/go.mau.fi/whatsmeow/types/group.go

@@ -0,0 +1,155 @@
+// Copyright (c) 2021 Tulir Asokan
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+package types
+
+import (
+	"time"
+)
+
+type GroupMemberAddMode string
+
+const (
+	GroupMemberAddModeAdmin     GroupMemberAddMode = "admin_add"
+	GroupMemberAddModeAllMember GroupMemberAddMode = "all_member_add"
+)
+
+// GroupInfo contains basic information about a group chat on WhatsApp.
+type GroupInfo struct {
+	JID      JID
+	OwnerJID JID
+
+	GroupName
+	GroupTopic
+	GroupLocked
+	GroupAnnounce
+	GroupEphemeral
+	GroupIncognito
+
+	GroupParent
+	GroupLinkedParent
+	GroupIsDefaultSub
+	GroupMembershipApprovalMode
+
+	GroupCreated time.Time
+
+	ParticipantVersionID string
+	Participants         []GroupParticipant
+
+	MemberAddMode GroupMemberAddMode
+}
+
+type GroupMembershipApprovalMode struct {
+	IsJoinApprovalRequired bool
+}
+
+type GroupParent struct {
+	IsParent                      bool
+	DefaultMembershipApprovalMode string // request_required
+}
+
+type GroupLinkedParent struct {
+	LinkedParentJID JID
+}
+
+type GroupIsDefaultSub struct {
+	IsDefaultSubGroup bool
+}
+
+// GroupName contains the name of a group along with metadata of who set it and when.
+type GroupName struct {
+	Name      string
+	NameSetAt time.Time
+	NameSetBy JID
+}
+
+// GroupTopic contains the topic (description) of a group along with metadata of who set it and when.
+type GroupTopic struct {
+	Topic        string
+	TopicID      string
+	TopicSetAt   time.Time
+	TopicSetBy   JID
+	TopicDeleted bool
+}
+
+// GroupLocked specifies whether the group info can only be edited by admins.
+type GroupLocked struct {
+	IsLocked bool
+}
+
+// GroupAnnounce specifies whether only admins can send messages in the group.
+type GroupAnnounce struct {
+	IsAnnounce        bool
+	AnnounceVersionID string
+}
+
+type GroupIncognito struct {
+	IsIncognito bool
+}
+
+// GroupParticipant contains info about a participant of a WhatsApp group chat.
+type GroupParticipant struct {
+	JID          JID
+	LID          JID
+	IsAdmin      bool
+	IsSuperAdmin bool
+
+	// This is only present for anonymous users in announcement groups, it's an obfuscated phone number
+	DisplayName string
+
+	// When creating groups, adding some participants may fail.
+	// In such cases, the error code will be here.
+	Error      int
+	AddRequest *GroupParticipantAddRequest
+}
+
+type GroupParticipantAddRequest struct {
+	Code       string
+	Expiration time.Time
+}
+
+// GroupEphemeral contains the group's disappearing messages settings.
+type GroupEphemeral struct {
+	IsEphemeral       bool
+	DisappearingTimer uint32
+}
+
+type GroupDelete struct {
+	Deleted      bool
+	DeleteReason string
+}
+
+type GroupLinkChangeType string
+
+const (
+	GroupLinkChangeTypeParent  GroupLinkChangeType = "parent_group"
+	GroupLinkChangeTypeSub     GroupLinkChangeType = "sub_group"
+	GroupLinkChangeTypeSibling GroupLinkChangeType = "sibling_group"
+)
+
+type GroupUnlinkReason string
+
+const (
+	GroupUnlinkReasonDefault GroupUnlinkReason = "unlink_group"
+	GroupUnlinkReasonDelete  GroupUnlinkReason = "delete_parent"
+)
+
+type GroupLinkTarget struct {
+	JID JID
+	GroupName
+	GroupIsDefaultSub
+}
+
+type GroupLinkChange struct {
+	Type         GroupLinkChangeType
+	UnlinkReason GroupUnlinkReason
+	Group        GroupLinkTarget
+}
+
+type GroupParticipantRequest struct {
+	JID         JID
+	RequestedAt time.Time
+}

slidge_whatsapp/vendor/go.mau.fi/whatsmeow/types/jid.go

@@ -0,0 +1,263 @@
+// Copyright (c) 2021 Tulir Asokan
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+// Package types contains various structs and other types used by whatsmeow.
+package types
+
+import (
+	"database/sql"
+	"database/sql/driver"
+	"fmt"
+	"regexp"
+	"strconv"
+	"strings"
+
+	signalProtocol "go.mau.fi/libsignal/protocol"
+)
+
+// Known JID servers on WhatsApp
+const (
+	DefaultUserServer = "s.whatsapp.net"
+	GroupServer       = "g.us"
+	LegacyUserServer  = "c.us"
+	BroadcastServer   = "broadcast"
+	HiddenUserServer  = "lid"
+	MessengerServer   = "msgr"
+	InteropServer     = "interop"
+	NewsletterServer  = "newsletter"
+	HostedServer      = "hosted"
+	BotServer         = "bot"
+)
+
+// Some JIDs that are contacted often.
+var (
+	EmptyJID            = JID{}
+	GroupServerJID      = NewJID("", GroupServer)
+	ServerJID           = NewJID("", DefaultUserServer)
+	BroadcastServerJID  = NewJID("", BroadcastServer)
+	StatusBroadcastJID  = NewJID("status", BroadcastServer)
+	PSAJID              = NewJID("0", LegacyUserServer)
+	OfficialBusinessJID = NewJID("16505361212", LegacyUserServer)
+	MetaAIJID           = NewJID("13135550002", DefaultUserServer)
+)
+
+// MessageID is the internal ID of a WhatsApp message.
+type MessageID = string
+
+// MessageServerID is the server ID of a WhatsApp newsletter message.
+type MessageServerID = int
+
+// JID represents a WhatsApp user ID.
+//
+// There are two types of JIDs: regular JID pairs (user and server) and AD-JIDs (user, agent and device).
+// AD JIDs are only used to refer to specific devices of users, so the server is always s.whatsapp.net (DefaultUserServer).
+// Regular JIDs can be used for entities on any servers (users, groups, broadcasts).
+type JID struct {
+	User       string
+	RawAgent   uint8
+	Device     uint16
+	Integrator uint16
+	Server     string
+}
+
+func (jid JID) ActualAgent() uint8 {
+	switch jid.Server {
+	case DefaultUserServer:
+		return 0
+	case HiddenUserServer:
+		return 1
+	default:
+		return jid.RawAgent
+	}
+}
+
+// UserInt returns the user as an integer. This is only safe to run on normal users, not on groups or broadcast lists.
+func (jid JID) UserInt() uint64 {
+	number, _ := strconv.ParseUint(jid.User, 10, 64)
+	return number
+}
+
+// ToNonAD returns a version of the JID struct that doesn't have the agent and device set.
+func (jid JID) ToNonAD() JID {
+	return JID{
+		User:       jid.User,
+		Server:     jid.Server,
+		Integrator: jid.Integrator,
+	}
+}
+
+// SignalAddress returns the Signal protocol address for the user.
+func (jid JID) SignalAddress() *signalProtocol.SignalAddress {
+	user := jid.User
+	agent := jid.ActualAgent()
+	if agent != 0 {
+		user = fmt.Sprintf("%s_%d", jid.User, agent)
+	}
+	return signalProtocol.NewSignalAddress(user, uint32(jid.Device))
+	// TODO use @lid suffix instead of agent?
+	//suffix := ""
+	//if jid.Server == HiddenUserServer {
+	//	suffix = "@lid"
+	//}
+	//return signalProtocol.NewSignalAddress(user, uint32(jid.Device), suffix)
+}
+
+// IsBroadcastList returns true if the JID is a broadcast list, but not the status broadcast.
+func (jid JID) IsBroadcastList() bool {
+	return jid.Server == BroadcastServer && jid.User != StatusBroadcastJID.User
+}
+
+var botUserRegex = regexp.MustCompile(`^1313555\d{4}$|^131655500\d{2}$`)
+
+func (jid JID) IsBot() bool {
+	return jid.Server == DefaultUserServer && botUserRegex.MatchString(jid.User) && jid.Device == 0
+}
+
+// NewADJID creates a new AD JID.
+func NewADJID(user string, agent, device uint8) JID {
+	var server string
+	switch agent {
+	case 0:
+		server = DefaultUserServer
+	case 1:
+		server = HiddenUserServer
+		agent = 0
+	default:
+		if (agent&0x01) != 0 || (agent&0x80) == 0 { // agent % 2 == 0 || agent < 128?
+			// TODO invalid JID?
+		}
+		server = HostedServer
+	}
+	return JID{
+		User:     user,
+		RawAgent: agent,
+		Device:   uint16(device),
+		Server:   server,
+	}
+}
+
+// ParseJID parses a JID out of the given string. It supports both regular and AD JIDs.
+func ParseJID(jid string) (JID, error) {
+	parts := strings.Split(jid, "@")
+	if len(parts) == 1 {
+		return NewJID("", parts[0]), nil
+	}
+	parsedJID := JID{User: parts[0], Server: parts[1]}
+	if strings.ContainsRune(parsedJID.User, '.') {
+		parts = strings.Split(parsedJID.User, ".")
+		if len(parts) != 2 {
+			return parsedJID, fmt.Errorf("unexpected number of dots in JID")
+		}
+		parsedJID.User = parts[0]
+		ad := parts[1]
+		parts = strings.Split(ad, ":")
+		if len(parts) > 2 {
+			return parsedJID, fmt.Errorf("unexpected number of colons in JID")
+		}
+		agent, err := strconv.Atoi(parts[0])
+		if err != nil {
+			return parsedJID, fmt.Errorf("failed to parse device from JID: %w", err)
+		}
+		parsedJID.RawAgent = uint8(agent)
+		if len(parts) == 2 {
+			device, err := strconv.Atoi(parts[1])
+			if err != nil {
+				return parsedJID, fmt.Errorf("failed to parse device from JID: %w", err)
+			}
+			parsedJID.Device = uint16(device)
+		}
+	} else if strings.ContainsRune(parsedJID.User, ':') {
+		parts = strings.Split(parsedJID.User, ":")
+		if len(parts) != 2 {
+			return parsedJID, fmt.Errorf("unexpected number of colons in JID")
+		}
+		parsedJID.User = parts[0]
+		device, err := strconv.Atoi(parts[1])
+		if err != nil {
+			return parsedJID, fmt.Errorf("failed to parse device from JID: %w", err)
+		}
+		parsedJID.Device = uint16(device)
+	}
+	return parsedJID, nil
+}
+
+// NewJID creates a new regular JID.
+func NewJID(user, server string) JID {
+	return JID{
+		User:   user,
+		Server: server,
+	}
+}
+
+func (jid JID) ADString() string {
+	return fmt.Sprintf("%s.%d:%d@%s", jid.User, jid.RawAgent, jid.Device, jid.Server)
+}
+
+// String converts the JID to a string representation.
+// The output string can be parsed with ParseJID.
+func (jid JID) String() string {
+	if jid.RawAgent > 0 {
+		return fmt.Sprintf("%s.%d:%d@%s", jid.User, jid.RawAgent, jid.Device, jid.Server)
+	} else if jid.Device > 0 {
+		return fmt.Sprintf("%s:%d@%s", jid.User, jid.Device, jid.Server)
+	} else if len(jid.User) > 0 {
+		return fmt.Sprintf("%s@%s", jid.User, jid.Server)
+	} else {
+		return jid.Server
+	}
+}
+
+// MarshalText implements encoding.TextMarshaler for JID
+func (jid JID) MarshalText() ([]byte, error) {
+	return []byte(jid.String()), nil
+}
+
+// UnmarshalText implements encoding.TextUnmarshaler for JID
+func (jid *JID) UnmarshalText(val []byte) error {
+	out, err := ParseJID(string(val))
+	if err != nil {
+		return err
+	}
+	*jid = out
+	return nil
+}
+
+// IsEmpty returns true if the JID has no server (which is required for all JIDs).
+func (jid JID) IsEmpty() bool {
+	return len(jid.Server) == 0
+}
+
+var _ sql.Scanner = (*JID)(nil)
+
+// Scan scans the given SQL value into this JID.
+func (jid *JID) Scan(src interface{}) error {
+	if src == nil {
+		return nil
+	}
+	var out JID
+	var err error
+	switch val := src.(type) {
+	case string:
+		out, err = ParseJID(val)
+	case []byte:
+		out, err = ParseJID(string(val))
+	default:
+		err = fmt.Errorf("unsupported type %T for scanning JID", val)
+	}
+	if err != nil {
+		return err
+	}
+	*jid = out
+	return nil
+}
+
+// Value returns the string representation of the JID as a value that the SQL package can use.
+func (jid JID) Value() (driver.Value, error) {
+	if len(jid.Server) == 0 {
+		return nil, nil
+	}
+	return jid.String(), nil
+}

slidge_whatsapp/vendor/go.mau.fi/whatsmeow/types/message.go

@@ -0,0 +1,98 @@
+// Copyright (c) 2021 Tulir Asokan
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+package types
+
+import (
+	"fmt"
+	"time"
+)
+
+// MessageSource contains basic sender and chat information about a message.
+type MessageSource struct {
+	Chat     JID  // The chat where the message was sent.
+	Sender   JID  // The user who sent the message.
+	IsFromMe bool // Whether the message was sent by the current user instead of someone else.
+	IsGroup  bool // Whether the chat is a group chat or broadcast list.
+
+	// When sending a read receipt to a broadcast list message, the Chat is the broadcast list
+	// and Sender is you, so this field contains the recipient of the read receipt.
+	BroadcastListOwner JID
+}
+
+// IsIncomingBroadcast returns true if the message was sent to a broadcast list instead of directly to the user.
+//
+// If this is true, it means the message shows up in the direct chat with the Sender.
+func (ms *MessageSource) IsIncomingBroadcast() bool {
+	return (!ms.IsFromMe || !ms.BroadcastListOwner.IsEmpty()) && ms.Chat.IsBroadcastList()
+}
+
+// DeviceSentMeta contains metadata from messages sent by another one of the user's own devices.
+type DeviceSentMeta struct {
+	DestinationJID string // The destination user. This should match the MessageInfo.Recipient field.
+	Phash          string
+}
+
+type EditAttribute string
+
+const (
+	EditAttributeEmpty        EditAttribute = ""
+	EditAttributeMessageEdit  EditAttribute = "1"
+	EditAttributePinInChat    EditAttribute = "2"
+	EditAttributeAdminEdit    EditAttribute = "3" // only used in newsletters
+	EditAttributeSenderRevoke EditAttribute = "7"
+	EditAttributeAdminRevoke  EditAttribute = "8"
+)
+
+type BotEditType string
+
+const (
+	EditTypeFirst BotEditType = "first"
+	EditTypeInner BotEditType = "inner"
+	EditTypeLast  BotEditType = "last"
+)
+
+// MsgBotInfo targets <bot>
+type MsgBotInfo struct {
+	EditType              BotEditType
+	EditTargetID          MessageID
+	EditSenderTimestampMS time.Time
+}
+
+// MsgMetaInfo targets <meta>
+type MsgMetaInfo struct {
+	TargetID     MessageID
+	TargetSender JID
+}
+
+// MessageInfo contains metadata about an incoming message.
+type MessageInfo struct {
+	MessageSource
+	ID        MessageID
+	ServerID  MessageServerID
+	Type      string
+	PushName  string
+	Timestamp time.Time
+	Category  string
+	Multicast bool
+	MediaType string
+	Edit      EditAttribute
+
+	MsgBotInfo  MsgBotInfo
+	MsgMetaInfo MsgMetaInfo
+
+	VerifiedName   *VerifiedName
+	DeviceSentMeta *DeviceSentMeta // Metadata for direct messages sent from another one of the user's own devices.
+}
+
+// SourceString returns a log-friendly representation of who sent the message and where.
+func (ms *MessageSource) SourceString() string {
+	if ms.Sender != ms.Chat {
+		return fmt.Sprintf("%s in %s", ms.Sender, ms.Chat)
+	} else {
+		return ms.Chat.String()
+	}
+}

slidge_whatsapp/vendor/go.mau.fi/whatsmeow/types/newsletter.go

@@ -0,0 +1,201 @@
+// Copyright (c) 2023 Tulir Asokan
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+package types
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"time"
+
+	"go.mau.fi/util/jsontime"
+
+	"go.mau.fi/whatsmeow/proto/waE2E"
+)
+
+type NewsletterVerificationState string
+
+func (nvs *NewsletterVerificationState) UnmarshalText(text []byte) error {
+	*nvs = NewsletterVerificationState(bytes.ToLower(text))
+	return nil
+}
+
+const (
+	NewsletterVerificationStateVerified   NewsletterVerificationState = "verified"
+	NewsletterVerificationStateUnverified NewsletterVerificationState = "unverified"
+)
+
+type NewsletterPrivacy string
+
+func (np *NewsletterPrivacy) UnmarshalText(text []byte) error {
+	*np = NewsletterPrivacy(bytes.ToLower(text))
+	return nil
+}
+
+const (
+	NewsletterPrivacyPrivate NewsletterPrivacy = "private"
+	NewsletterPrivacyPublic  NewsletterPrivacy = "public"
+)
+
+type NewsletterReactionsMode string
+
+const (
+	NewsletterReactionsModeAll       NewsletterReactionsMode = "all"
+	NewsletterReactionsModeBasic     NewsletterReactionsMode = "basic"
+	NewsletterReactionsModeNone      NewsletterReactionsMode = "none"
+	NewsletterReactionsModeBlocklist NewsletterReactionsMode = "blocklist"
+)
+
+type NewsletterState string
+
+func (ns *NewsletterState) UnmarshalText(text []byte) error {
+	*ns = NewsletterState(bytes.ToLower(text))
+	return nil
+}
+
+const (
+	NewsletterStateActive       NewsletterState = "active"
+	NewsletterStateSuspended    NewsletterState = "suspended"
+	NewsletterStateGeoSuspended NewsletterState = "geosuspended"
+)
+
+type NewsletterMuted struct {
+	Muted bool
+}
+
+type WrappedNewsletterState struct {
+	Type NewsletterState `json:"type"`
+}
+
+type NewsletterMuteState string
+
+func (nms *NewsletterMuteState) UnmarshalText(text []byte) error {
+	*nms = NewsletterMuteState(bytes.ToLower(text))
+	return nil
+}
+
+const (
+	NewsletterMuteOn  NewsletterMuteState = "on"
+	NewsletterMuteOff NewsletterMuteState = "off"
+)
+
+type NewsletterRole string
+
+func (nr *NewsletterRole) UnmarshalText(text []byte) error {
+	*nr = NewsletterRole(bytes.ToLower(text))
+	return nil
+}
+
+const (
+	NewsletterRoleSubscriber NewsletterRole = "subscriber"
+	NewsletterRoleGuest      NewsletterRole = "guest"
+	NewsletterRoleAdmin      NewsletterRole = "admin"
+	NewsletterRoleOwner      NewsletterRole = "owner"
+)
+
+type NewsletterMetadata struct {
+	ID         JID                       `json:"id"`
+	State      WrappedNewsletterState    `json:"state"`
+	ThreadMeta NewsletterThreadMetadata  `json:"thread_metadata"`
+	ViewerMeta *NewsletterViewerMetadata `json:"viewer_metadata"`
+}
+
+type NewsletterViewerMetadata struct {
+	Mute NewsletterMuteState `json:"mute"`
+	Role NewsletterRole      `json:"role"`
+}
+
+type NewsletterKeyType string
+
+const (
+	NewsletterKeyTypeJID    NewsletterKeyType = "JID"
+	NewsletterKeyTypeInvite NewsletterKeyType = "INVITE"
+)
+
+type NewsletterReactionSettings struct {
+	Value NewsletterReactionsMode `json:"value"`
+}
+
+type NewsletterSettings struct {
+	ReactionCodes NewsletterReactionSettings `json:"reaction_codes"`
+}
+
+type NewsletterThreadMetadata struct {
+	CreationTime      jsontime.UnixString         `json:"creation_time"`
+	InviteCode        string                      `json:"invite"`
+	Name              NewsletterText              `json:"name"`
+	Description       NewsletterText              `json:"description"`
+	SubscriberCount   int                         `json:"subscribers_count,string"`
+	VerificationState NewsletterVerificationState `json:"verification"`
+	Picture           *ProfilePictureInfo         `json:"picture"`
+	Preview           ProfilePictureInfo          `json:"preview"`
+	Settings          NewsletterSettings          `json:"settings"`
+
+	//NewsletterMuted `json:"-"`
+	//PrivacyType     NewsletterPrivacy       `json:"-"`
+	//ReactionsMode   NewsletterReactionsMode `json:"-"`
+	//State           NewsletterState         `json:"-"`
+}
+
+type NewsletterText struct {
+	Text       string                   `json:"text"`
+	ID         string                   `json:"id"`
+	UpdateTime jsontime.UnixMicroString `json:"update_time"`
+}
+
+type NewsletterMessage struct {
+	MessageServerID MessageServerID
+	MessageID       MessageID
+	Type            string
+	Timestamp       time.Time
+	ViewsCount      int
+	ReactionCounts  map[string]int
+
+	// This is only present when fetching messages, not in live updates
+	Message *waE2E.Message
+}
+
+type GraphQLErrorExtensions struct {
+	ErrorCode   int    `json:"error_code"`
+	IsRetryable bool   `json:"is_retryable"`
+	Severity    string `json:"severity"`
+}
+
+type GraphQLError struct {
+	Extensions GraphQLErrorExtensions `json:"extensions"`
+	Message    string                 `json:"message"`
+	Path       []string               `json:"path"`
+}
+
+func (gqle GraphQLError) Error() string {
+	return fmt.Sprintf("%d %s (%s)", gqle.Extensions.ErrorCode, gqle.Message, gqle.Extensions.Severity)
+}
+
+type GraphQLErrors []GraphQLError
+
+func (gqles GraphQLErrors) Unwrap() []error {
+	errs := make([]error, len(gqles))
+	for i, gqle := range gqles {
+		errs[i] = gqle
+	}
+	return errs
+}
+
+func (gqles GraphQLErrors) Error() string {
+	if len(gqles) == 0 {
+		return ""
+	} else if len(gqles) == 1 {
+		return gqles[0].Error()
+	} else {
+		return fmt.Sprintf("%v (and %d other errors)", gqles[0], len(gqles)-1)
+	}
+}
+
+type GraphQLResponse struct {
+	Data   json.RawMessage `json:"data"`
+	Errors GraphQLErrors   `json:"errors"`
+}