slidge 0.1.0rc1__py3-none-any.whl → 0.1.2__py3-none-any.whl

slidge/plugins/whatsapp/event.go

@@ -1,455 +0,0 @@
-package whatsapp
-
-import (
-	// Standard library.
-	"context"
-	"fmt"
-	"mime"
-
-	// Third-party libraries.
-	"go.mau.fi/whatsmeow"
-	"go.mau.fi/whatsmeow/binary/proto"
-	"go.mau.fi/whatsmeow/types"
-	"go.mau.fi/whatsmeow/types/events"
-)
-
-// EventKind represents all event types recognized by the Python session adapter, as emitted by the
-// Go session adapter.
-type EventKind int
-
-// The event types handled by the overarching session adapter handler.
-const (
-	EventUnknown EventKind = iota
-	EventQRCode
-	EventPairSuccess
-	EventConnected
-	EventLoggedOut
-	EventContactSync
-	EventPresence
-	EventMessage
-	EventChatState
-	EventReceipt
-	EventCall
-)
-
-// EventPayload represents the collected payloads for all event types handled by the overarching
-// session adapter handler. Only specific fields will be populated in events emitted by internal
-// handlers, see documentation for specific types for more information.
-type EventPayload struct {
-	QRCode       string
-	PairDeviceID string
-	Contact      Contact
-	Presence     Presence
-	Message      Message
-	ChatState    ChatState
-	Receipt      Receipt
-	Call         Call
-}
-
-// A Contact represents any entity that be communicated with directly in WhatsApp. This typically
-// represents people, but may represent a business or bot as well, but not a group-chat.
-type Contact struct {
-	JID       string
-	Name      string
-	AvatarURL string
-}
-
-// NewContactSyncEvent 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 newContactSyncEvent(c *whatsmeow.Client, jid types.JID, info types.ContactInfo) (EventKind, *EventPayload) {
-	var contact = Contact{
-		JID: jid.ToNonAD().String(),
-	}
-
-	for _, n := range []string{info.FullName, info.FirstName, info.BusinessName, info.PushName} {
-		if n != "" {
-			contact.Name = n
-			break
-		}
-	}
-
-	// Don't attempt to synchronize contacts with no user-readable name.
-	if contact.Name == "" {
-		return EventUnknown, nil
-	}
-
-	if p, _ := c.GetProfilePictureInfo(jid, nil); p != nil {
-		contact.AvatarURL = p.URL
-	}
-
-	return EventContactSync, &EventPayload{Contact: contact}
-}
-
-// Precence represents a contact's general state of activity, and is periodically updated as
-// contacts start or stop paying attention to their client of choice.
-type Presence struct {
-	JID      string
-	Away     bool
-	LastSeen int64
-}
-
-// NewPresenceEvent returns event data meant for [Session.propagateEvent] for the primitive presence
-// event given.
-func newPresenceEvent(evt *events.Presence) (EventKind, *EventPayload) {
-	return EventPresence, &EventPayload{Presence: Presence{
-		JID:      evt.From.ToNonAD().String(),
-		Away:     evt.Unavailable,
-		LastSeen: evt.LastSeen.Unix(),
-	}}
-}
-
-// MessageKind represents all concrete message types (plain-text messages, edit messages, reactions)
-// recognized by the Python session adapter.
-type MessageKind int
-
-// The message types handled by the overarching session event handler.
-const (
-	MessagePlain MessageKind = 1 + iota
-	MessageRevoke
-	MessageReaction
-	MessageAttachment
-)
-
-// A Message represents one of many kinds of bidirectional communication payloads, for example, a
-// text message, a file (image, video) attachment, an emoji reaction, etc. Messages of different
-// kinds are denoted as such, and re-use fields where the semantics overlap.
-type Message struct {
-	Kind        MessageKind  // The concrete message kind being sent or received.
-	ID          string       // The unique message ID, used for referring to a specific Message instance.
-	JID         string       // The JID this message concerns, semantics can change based on IsCarbon.
-	Body        string       // The plain-text message body. For attachment messages, this can be a caption.
-	Timestamp   int64        // The Unix timestamp denoting when this message was created.
-	IsCarbon    bool         // Whether or not this message concerns the gateway user themselves.
-	ReplyID     string       // The unique message ID this message is in reply to, if any.
-	ReplyBody   string       // The full body of the message this message is in reply to, if any.
-	Attachments []Attachment // The list of file (image, video, etc.) attachments contained in this message.
-}
-
-// A Attachment represents additional binary data (e.g. images, videos, documents) provided alongside
-// a message, for display or storage on the recepient client.
-type Attachment struct {
-	MIME     string // The MIME type for attachment.
-	Filename string // The recommended file name for this attachment. May be an auto-generated name.
-	Caption  string // The user-provided caption, provided alongside this attachment.
-	Data     []byte // The raw binary data for this attachment. Mutually exclusive with [.URL].
-	URL      string // The URL to download attachment data from. Mutually exclusive with [.Data].
-}
-
-// GenerateMessageID returns a valid, pseudo-random message ID for use in outgoing messages. This
-// function will panic if there is no entropy available for random ID generation.
-func GenerateMessageID() string {
-	return whatsmeow.GenerateMessageID()
-}
-
-// 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) {
-	// Ignore incoming messages sent or received over group-chats until proper support is implemented.
-	if evt.Info.IsGroup {
-		return EventUnknown, nil
-	}
-
-	// Set basic data for message, to be potentially amended depending on the concrete version of
-	// the underlying message.
-	var message = Message{
-		Kind:      MessagePlain,
-		ID:        evt.Info.ID,
-		Body:      evt.Message.GetConversation(),
-		Timestamp: evt.Info.Timestamp.Unix(),
-		IsCarbon:  evt.Info.IsFromMe,
-	}
-
-	// Set message JID based on whether a message is originating from ourselves or someone else.
-	if message.IsCarbon {
-		message.JID = evt.Info.MessageSource.Chat.ToNonAD().String()
-	} else {
-		message.JID = evt.Info.MessageSource.Sender.ToNonAD().String()
-	}
-
-	// Handle handle protocol messages (such as message deletion or editing).
-	if p := evt.Message.GetProtocolMessage(); p != nil {
-		switch p.GetType() {
-		case proto.ProtocolMessage_REVOKE:
-			message.Kind = MessageRevoke
-			message.ID = p.Key.GetId()
-			return EventMessage, &EventPayload{Message: message}
-		}
-	}
-
-	// Handle emoji reaction to existing message.
-	if r := evt.Message.GetReactionMessage(); r != nil {
-		message.Kind = MessageReaction
-		message.ID = r.Key.GetId()
-		message.Body = r.GetText()
-		return EventMessage, &EventPayload{Message: message}
-	}
-
-	// Handle message attachments, if any.
-	if attach, err := getMessageAttachments(client, evt.Message); err != nil {
-		client.Log.Errorf("Failed getting message attachments: %s", err)
-		return EventUnknown, nil
-	} else if len(attach) > 0 {
-		message.Attachments = append(message.Attachments, attach...)
-		message.Kind = MessageAttachment
-	}
-
-	// Get extended information from message, if available. Extended messages typically represent
-	// messages with additional context, such as replies, forwards, etc.
-	if e := evt.Message.GetExtendedTextMessage(); e != nil {
-		if message.Body == "" {
-			message.Body = e.GetText()
-		}
-		if c := e.GetContextInfo(); c != nil {
-			message.ReplyID = c.GetStanzaId()
-			if q := c.GetQuotedMessage(); q != nil {
-				message.ReplyBody = q.GetConversation()
-			}
-		}
-	}
-
-	// Ignore obviously invalid messages.
-	if message.Kind == MessagePlain && message.Body == "" {
-		return EventUnknown, nil
-	}
-
-	return EventMessage, &EventPayload{Message: message}
-}
-
-// GetMessageAttachments fetches and decrypts attachments (images, audio, video, or documents) sent
-// via WhatsApp. Any failures in retrieving any attachment will return an error immediately.
-func getMessageAttachments(client *whatsmeow.Client, message *proto.Message) ([]Attachment, error) {
-	var result []Attachment
-	var kinds = []whatsmeow.DownloadableMessage{
-		message.GetImageMessage(),
-		message.GetAudioMessage(),
-		message.GetVideoMessage(),
-		message.GetDocumentMessage(),
-	}
-
-	for _, msg := range kinds {
-		// Handle data for specific attachment type.
-		var a Attachment
-		switch msg := msg.(type) {
-		case *proto.ImageMessage:
-			a.MIME, a.Caption = msg.GetMimetype(), msg.GetCaption()
-		case *proto.AudioMessage:
-			a.MIME = msg.GetMimetype()
-		case *proto.VideoMessage:
-			a.MIME, a.Caption = msg.GetMimetype(), msg.GetCaption()
-		case *proto.DocumentMessage:
-			a.MIME, a.Caption, a.Filename = msg.GetMimetype(), msg.GetCaption(), msg.GetFileName()
-		}
-
-		// Ignore attachments with empty or unknown MIME types.
-		if a.MIME == "" {
-			continue
-		}
-
-		// Set filename from SHA256 checksum and MIME type, if none is already set.
-		if a.Filename == "" {
-			a.Filename = fmt.Sprintf("%x%s", msg.GetFileSha256(), extensionByType(a.MIME))
-		}
-
-		// Attempt to download and decrypt raw attachment data, if any.
-		data, err := client.Download(msg)
-		if err != nil {
-			return nil, err
-		}
-
-		a.Data = data
-		result = append(result, a)
-	}
-
-	return result, nil
-}
-
-// KnownMediaTypes represents MIME type to WhatsApp media types known to be handled by WhatsApp in a
-// special way (that is, not as generic file uploads).
-var knownMediaTypes = map[string]whatsmeow.MediaType{
-	"image/jpeg":      whatsmeow.MediaImage,
-	"audio/ogg":       whatsmeow.MediaAudio,
-	"application/ogg": whatsmeow.MediaAudio,
-	"video/mp4":       whatsmeow.MediaVideo,
-}
-
-// UploadAttachment attempts to push the given attachment data to WhatsApp according to the MIME type
-// specified within. Attachments are handled as generic file uploads unless they're of a specific
-// format, see [knownMediaTypes] for more information.
-func uploadAttachment(client *whatsmeow.Client, attach Attachment) (*proto.Message, error) {
-	mediaType := knownMediaTypes[attach.MIME]
-	if mediaType == "" {
-		mediaType = whatsmeow.MediaDocument
-	}
-
-	upload, err := client.Upload(context.Background(), attach.Data, mediaType)
-	if err != nil {
-		return nil, err
-	}
-
-	var message *proto.Message
-	switch mediaType {
-	case whatsmeow.MediaImage:
-		message = &proto.Message{
-			ImageMessage: &proto.ImageMessage{
-				Url:           &upload.URL,
-				DirectPath:    &upload.DirectPath,
-				MediaKey:      upload.MediaKey,
-				Mimetype:      &attach.MIME,
-				FileEncSha256: upload.FileEncSHA256,
-				FileSha256:    upload.FileSHA256,
-				FileLength:    ptrTo(uint64(len(attach.Data))),
-			},
-		}
-	case whatsmeow.MediaAudio:
-		message = &proto.Message{
-			AudioMessage: &proto.AudioMessage{
-				Url:           &upload.URL,
-				DirectPath:    &upload.DirectPath,
-				MediaKey:      upload.MediaKey,
-				Mimetype:      &attach.MIME,
-				FileEncSha256: upload.FileEncSHA256,
-				FileSha256:    upload.FileSHA256,
-				FileLength:    ptrTo(uint64(len(attach.Data))),
-			},
-		}
-	case whatsmeow.MediaVideo:
-		message = &proto.Message{
-			VideoMessage: &proto.VideoMessage{
-				Url:           &upload.URL,
-				DirectPath:    &upload.DirectPath,
-				MediaKey:      upload.MediaKey,
-				Mimetype:      &attach.MIME,
-				FileEncSha256: upload.FileEncSHA256,
-				FileSha256:    upload.FileSHA256,
-				FileLength:    ptrTo(uint64(len(attach.Data))),
-			}}
-	case whatsmeow.MediaDocument:
-		message = &proto.Message{
-			DocumentMessage: &proto.DocumentMessage{
-				Url:           &upload.URL,
-				DirectPath:    &upload.DirectPath,
-				MediaKey:      upload.MediaKey,
-				Mimetype:      &attach.MIME,
-				FileEncSha256: upload.FileEncSHA256,
-				FileSha256:    upload.FileSHA256,
-				FileLength:    ptrTo(uint64(len(attach.Data))),
-				FileName:      &attach.Filename,
-			}}
-	}
-
-	return message, nil
-}
-
-// ExtensionByType returns the file extension for the given MIME type, or a generic extension if the
-// MIME type is unknown.
-func extensionByType(typ string) string {
-	if ext, _ := mime.ExtensionsByType(typ); len(ext) > 0 {
-		return ext[0]
-	}
-	return ".bin"
-}
-
-// ChatStateKind represents the different kinds of chat-states possible in WhatsApp.
-type ChatStateKind int
-
-// The chat states handled by the overarching session event handler.
-const (
-	ChatStateComposing ChatStateKind = 1 + iota
-	ChatStatePaused
-)
-
-// A ChatState represents the activity of a contact within a certain discussion, for instance,
-// whether the contact is currently composing a message. This is separate to the concept of a
-// Presence, which is the contact's general state across all discussions.
-type ChatState struct {
-	JID  string
-	Kind ChatStateKind
-}
-
-// NewChatStateEvent returns event data meant for [Session.propagateEvent] for the primitive
-// chat-state event given.
-func newChatStateEvent(evt *events.ChatPresence) (EventKind, *EventPayload) {
-	var state = ChatState{JID: evt.MessageSource.Sender.ToNonAD().String()}
-	switch evt.State {
-	case types.ChatPresenceComposing:
-		state.Kind = ChatStateComposing
-	case types.ChatPresencePaused:
-		state.Kind = ChatStatePaused
-	}
-	return EventChatState, &EventPayload{ChatState: state}
-}
-
-// ReceiptKind represents the different types of delivery receipts possible in WhatsApp.
-type ReceiptKind int
-
-// The delivery receipts handled by the overarching session event handler.
-const (
-	ReceiptDelivered ReceiptKind = 1 + iota
-	ReceiptRead
-)
-
-// A Receipt represents a notice of delivery or presentation for [Message] instances sent or
-// received. Receipts can be delivered for many messages at once, but are generally all delivered
-// under one specific state at a time.
-type Receipt struct {
-	Kind       ReceiptKind
-	MessageIDs []string
-	JID        string
-	Timestamp  int64
-	IsCarbon   bool
-}
-
-// 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) {
-	var receipt = Receipt{
-		MessageIDs: append([]string{}, evt.MessageIDs...),
-		Timestamp:  evt.Timestamp.Unix(),
-		IsCarbon:   evt.MessageSource.IsFromMe,
-	}
-
-	if len(receipt.MessageIDs) == 0 {
-		return EventUnknown, nil
-	}
-
-	if receipt.IsCarbon {
-		receipt.JID = evt.MessageSource.Chat.ToNonAD().String()
-	} else {
-		receipt.JID = evt.MessageSource.Sender.ToNonAD().String()
-	}
-
-	switch evt.Type {
-	case events.ReceiptTypeDelivered:
-		receipt.Kind = ReceiptDelivered
-	case events.ReceiptTypeRead:
-		receipt.Kind = ReceiptRead
-	}
-
-	return EventReceipt, &EventPayload{Receipt: receipt}
-}
-
-// CallState represents the state of the call to synchronize with.
-type CallState int
-
-// The calls tates handled by the overarching session event handler.
-const (
-	CallMissed CallState = 1 + iota
-)
-
-// A Call represents an incoming or outgoing voice/video call made over WhatsApp. Full support for
-// calls is currently not implemented, and this structure contains the bare minimum data required
-// for notifying on missed calls.
-type Call struct {
-	State     CallState
-	JID       string
-	Timestamp int64
-}
-
-// NewCallEvent returns event data meant for [Session.propagateEvent] for the call metadata given.
-func newCallEvent(state CallState, meta types.BasicCallMeta) (EventKind, *EventPayload) {
-	return EventCall, &EventPayload{Call: Call{
-		State:     state,
-		JID:       meta.From.ToNonAD().String(),
-		Timestamp: meta.Timestamp.Unix(),
-	}}
-}

slidge/plugins/whatsapp/gateway.go

@@ -1,156 +0,0 @@
-package whatsapp
-
-import (
-	// Standard library.
-	"crypto/tls"
-	"fmt"
-	"net/http"
-	"runtime"
-	"time"
-
-	// Third-party libraries.
-	_ "github.com/mattn/go-sqlite3"
-	"go.mau.fi/whatsmeow/store"
-	"go.mau.fi/whatsmeow/store/sqlstore"
-	"go.mau.fi/whatsmeow/types"
-	walog "go.mau.fi/whatsmeow/util/log"
-)
-
-// A LinkedDevice represents a unique pairing session between the gateway and WhatsApp. It is not
-// unique to the underlying "main" device (or phone number), as multiple linked devices may be paired
-// with any main device.
-type LinkedDevice struct {
-	// ID is an opaque string identifying this LinkedDevice to the Session. Noted that this string
-	// is currently equivalent to a password, and needs to be protected accordingly.
-	ID string
-}
-
-// JID returns the WhatsApp JID corresponding to the LinkedDevice ID. Empty or invalid device IDs
-// may return invalid JIDs, and this function does not handle errors.
-func (d LinkedDevice) JID() types.JID {
-	jid, _ := types.ParseJID(d.ID)
-	return jid
-}
-
-// A ErrorLevel is a value representing the severity of a log message being handled.
-type ErrorLevel int
-
-// The log levels handled by the overarching Session logger.
-const (
-	LevelError ErrorLevel = 1 + iota
-	LevelWarning
-	LevelInfo
-	LevelDebug
-)
-
-// HandleLogFunc is the signature for the overarching Gateway log handling function.
-type HandleLogFunc func(ErrorLevel, string)
-
-// Errorf handles the given message as representing a (typically) fatal error.
-func (h HandleLogFunc) Errorf(msg string, args ...interface{}) {
-	h(LevelError, fmt.Sprintf(msg, args...))
-}
-
-// Warn handles the given message as representing a non-fatal error or warning thereof.
-func (h HandleLogFunc) Warnf(msg string, args ...interface{}) {
-	h(LevelWarning, fmt.Sprintf(msg, args...))
-}
-
-// Infof handles the given message as representing an informational notice.
-func (h HandleLogFunc) Infof(msg string, args ...interface{}) {
-	h(LevelInfo, fmt.Sprintf(msg, args...))
-}
-
-// Debugf handles the given message as representing an internal-only debug message.
-func (h HandleLogFunc) Debugf(msg string, args ...interface{}) {
-	h(LevelDebug, fmt.Sprintf(msg, args...))
-}
-
-// Sub is a no-op and will return the receiver itself.
-func (h HandleLogFunc) Sub(string) walog.Logger {
-	return h
-}
-
-// A Gateway represents a persistent process for establishing individual sessions between linked
-// devices and WhatsApp.
-type Gateway struct {
-	DBPath        string // The filesystem path for the client database.
-	Name          string // The name to display when linking devices on WhatsApp.
-	SkipVerifyTLS bool   // Whether or not our internal HTTP client will skip TLS certificate verification.
-
-	// Internal variables.
-	container  *sqlstore.Container
-	httpClient *http.Client
-	logger     walog.Logger
-}
-
-// NewSession returns a new for the LinkedDevice given. If the linked device does not have a valid
-// ID, a pair operation will be required, as described in [Session.Login].
-func (w *Gateway) NewSession(device LinkedDevice) *Session {
-	return &Session{device: device, gateway: w}
-}
-
-// CleanupSession will remove all invalid and obsolete references to the given device, and should be
-// used when pairing a new device or unregistering from the Gateway.
-func (w *Gateway) CleanupSession(device LinkedDevice) error {
-	devices, err := w.container.GetAllDevices()
-	if err != nil {
-		return err
-	}
-
-	for _, d := range devices {
-		if d.ID == nil {
-			w.logger.Infof("Removing invalid device %s from database", d.ID.String())
-			_ = d.Delete()
-		} else if device.ID != "" {
-			if jid := device.JID(); d.ID.ToNonAD() == jid.ToNonAD() && *d.ID != jid {
-				w.logger.Infof("Removing obsolete device %s from database", d.ID.String())
-				_ = d.Delete()
-			}
-		}
-	}
-
-	return nil
-}
-
-// Init performs initialization procedures for the Gateway, and is expected to be run before any
-// calls to [Gateway.Session].
-func (w *Gateway) Init() error {
-	container, err := sqlstore.New("sqlite3", w.DBPath, w.logger)
-	if err != nil {
-		return err
-	}
-
-	if w.Name != "" {
-		store.SetOSInfo(w.Name, [...]uint32{1, 0, 0})
-	}
-
-	// Set up shared HTTP client with less lenient timeouts.
-	w.httpClient = &http.Client{
-		Timeout: time.Second * 10,
-		Transport: &http.Transport{
-			TLSClientConfig: &tls.Config{InsecureSkipVerify: w.SkipVerifyTLS},
-		},
-	}
-
-	w.container = container
-	return nil
-}
-
-// SetLogHandler specifies the log handling function to use for all [Gateway] and [Session] operations.
-func (w *Gateway) SetLogHandler(h HandleLogFunc) {
-	w.logger = HandleLogFunc(func(level ErrorLevel, message string) {
-		// Don't allow other Goroutines from using this thread, as this might lead to concurrent
-		// use of the GIL, which can lead to crashes.
-		runtime.LockOSThread()
-		defer runtime.UnlockOSThread()
-
-		h(level, message)
-	})
-}
-
-// NewGateway returns a new, un-initialized Gateway. This function should always be followed by calls
-// to [Gateway.Init], assuming a valid [Gateway.DBPath] is set.
-func NewGateway() *Gateway {
-	return &Gateway{}
-}

slidge/plugins/whatsapp/gateway.py

@@ -1,69 +0,0 @@
-from logging import getLogger
-from pathlib import Path
-from shelve import open
-
-from slidge import BaseGateway, GatewayUser, global_config
-from slidge.plugins.whatsapp.generated import whatsapp
-
-from . import config
-
-REGISTRATION_INSTRUCTIONS = (
-    "Continue and scan the resulting QR codes on your main device to complete registration. "
-    "More information at https://slidge.readthedocs.io/en/latest/user/plugins/whatsapp.html"
-)
-
-WELCOME_MESSAGE = (
-    "Thank you for registering! Please scan the following QR code on your main device to complete "
-    "registration, or type 'help' to list other available commands."
-)
-
-
-class Gateway(BaseGateway):
-    COMPONENT_NAME = "WhatsApp (slidge)"
-    COMPONENT_TYPE = "whatsapp"
-    COMPONENT_AVATAR = "https://www.whatsapp.com/apple-touch-icon.png"
-    REGISTRATION_INSTRUCTIONS = REGISTRATION_INSTRUCTIONS
-    WELCOME_MESSAGE = WELCOME_MESSAGE
-    REGISTRATION_FIELDS = []
-    ROSTER_GROUP = "WhatsApp"
-    MARK_ALL_MESSAGES = True
-
-    def __init__(self):
-        super().__init__()
-        Path(config.DB_PATH.parent).mkdir(exist_ok=True)
-        self.whatsapp = whatsapp.NewGateway()
-        self.whatsapp.SetLogHandler(handle_log)
-        self.whatsapp.DBPath = str(config.DB_PATH)
-        self.whatsapp.SkipVerifyTLS = config.SKIP_VERIFY_TLS
-        self.whatsapp.Name = "Slidge on " + str(global_config.JID)
-        self.whatsapp.Init()
-
-    async def unregister(self, user: GatewayUser):
-        user_shelf_path = (
-            global_config.HOME_DIR / "whatsapp" / (user.bare_jid + ".shelf")
-        )
-        with open(str(user_shelf_path)) as shelf:
-            try:
-                device = whatsapp.LinkedDevice(ID=shelf["device_id"])
-                self.whatsapp.CleanupSession(device)
-            except KeyError:
-                pass
-            except RuntimeError as err:
-                log.error("Failed to clean up WhatsApp session: %s", err)
-
-
-def handle_log(level, msg: str):
-    """
-    Log given message of specified level in system-wide logger.
-    """
-    if level == whatsapp.LevelError:
-        log.error(msg)
-    elif level == whatsapp.LevelWarning:
-        log.warning(msg)
-    elif level == whatsapp.LevelDebug:
-        log.debug(msg)
-    else:
-        log.info(msg)
-
-
-log = getLogger(__name__)

slidge/plugins/whatsapp/go.mod

@@ -1,17 +0,0 @@
-module git.sr.ht/~nicoco/slidge/slidge/plugins/whatsapp
-
-go 1.19
-
-require (
-	github.com/go-python/gopy v0.4.5
-	github.com/mattn/go-sqlite3 v1.14.16
-	go.mau.fi/libsignal v0.0.0-20221015105917-d970e7c3c9cf
-	go.mau.fi/whatsmeow v0.0.0-20221213225758-70ef67df3c68
-)
-
-require (
-	filippo.io/edwards25519 v1.0.0 // indirect
-	github.com/gorilla/websocket v1.5.0 // indirect
-	golang.org/x/crypto v0.0.0-20221012134737-56aed061732a // indirect
-	google.golang.org/protobuf v1.28.1 // indirect
-)