slidge-whatsapp 0.2.2__cp313-cp313-manylinux_2_36_x86_64.whl

slidge_whatsapp/go.sum

@@ -0,0 +1,62 @@
+filippo.io/edwards25519 v1.1.0 h1:FNf4tywRC1HmFuKW5xopWpigGjJKiJSV0Cqo0cJWDaA=
+filippo.io/edwards25519 v1.1.0/go.mod h1:BxyFTGdWcka3PhytdK4V28tE5sGfRvvvRV7EaN4VDT4=
+github.com/coreos/go-systemd/v22 v22.5.0/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/ebitengine/purego v0.8.2 h1:jPPGWs2sZ1UgOSgD2bClL0MJIqu58nOmIcBuXr62z1I=
+github.com/ebitengine/purego v0.8.2/go.mod h1:iIjxzd6CiRiOG0UyXP+V1+jWqUXVjPKLAI0mRfJZTmQ=
+github.com/gen2brain/go-fitz v1.24.14 h1:09weRkjVtLYNGo7l0J7DyOwBExbwi8SJ9h8YPhw9WEo=
+github.com/gen2brain/go-fitz v1.24.14/go.mod h1:0KaZeQgASc20Yp5R/pFzyy7SmP01XcoHKNF842U2/S4=
+github.com/go-python/gopy v0.4.11-0.20241206185020-5f285b890023 h1:XTSDrwAmmX5o2lKeIYfKbCPYPMaDSDYvknkYADJKpxE=
+github.com/go-python/gopy v0.4.11-0.20241206185020-5f285b890023/go.mod h1:zMV/gSSYa9u/8Zp0WYR+L/z+kOIqIUtMg/a1/GRy5uw=
+github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA=
+github.com/google/go-cmp v0.5.5 h1:Khx7svrCpmxxtHBq5j2mp/xVjsi8hQMfNLvJFAlrGgU=
+github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
+github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg=
+github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
+github.com/h2non/filetype v1.1.3 h1:FKkx9QbD7HR/zjK1Ia5XiBsq9zdLi5Kf3zGyFTAFkGg=
+github.com/h2non/filetype v1.1.3/go.mod h1:319b3zT68BvV+WRj7cwy856M2ehB3HqNOt6sy1HndBY=
+github.com/jupiterrider/ffi v0.3.0 h1:F8N2IgRMNlL2fsO2oeE6QYW60vKhFVqQe5qVKwd/taU=
+github.com/jupiterrider/ffi v0.3.0/go.mod h1:1QCaf2VVPpGyIeU3RqQ2rHYrAPT8m9l0GhQupVYQB24=
+github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
+github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHPsaIE=
+github.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8=
+github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
+github.com/mattn/go-isatty v0.0.19/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
+github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/mattn/go-sqlite3 v1.14.24 h1:tpSp2G2KyMnnQu99ngJ47EIkWVmliIizyZBfPrBWDRM=
+github.com/mattn/go-sqlite3 v1.14.24/go.mod h1:Uh1q+B4BYcTPb+yiD3kU8Ct7aC0hY9fxUwlHK0RXw+Y=
+github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/rs/xid v1.5.0/go.mod h1:trrq9SKmegXys3aeAKXMUTdJsYXVwGY3RLcfgqegfbg=
+github.com/rs/zerolog v1.33.0 h1:1cU2KZkvPxNyfgEmhHAz/1A9Bz+llsdYzklWFzgp0r8=
+github.com/rs/zerolog v1.33.0/go.mod h1:/7mN4D5sKwJLZQ2b/znpjC3/GQWY/xaDXUM0kKWRHss=
+github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
+github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+go.mau.fi/libsignal v0.1.1 h1:m/0PGBh4QKP/I1MQ44ti4C0fMbLMuHb95cmDw01FIpI=
+go.mau.fi/libsignal v0.1.1/go.mod h1:QLs89F/OA3ThdSL2Wz2p+o+fi8uuQUz0e1BRa6ExdBw=
+go.mau.fi/util v0.8.4 h1:mVKlJcXWfVo8ZW3f4vqtjGpqtZqJvX4ETekxawt2vnQ=
+go.mau.fi/util v0.8.4/go.mod h1:MOfGTs1CBuK6ERTcSL4lb5YU7/ujz09eOPVEDckuazY=
+go.mau.fi/whatsmeow v0.0.0-20250104105216-918c879fcd19 h1:uVS+Zct5fF8rSXV9lfs87zoXdge0JXTzVGNkjmZ61UU=
+go.mau.fi/whatsmeow v0.0.0-20250104105216-918c879fcd19/go.mod h1:TLzm2XkwgufONEmiVAsFny+9uBqyEZnUoPrQAfMyuSU=
+golang.org/x/crypto v0.32.0 h1:euUpcYgM8WcP71gNpTqQCn6rC2t6ULUPiOzfWaXVVfc=
+golang.org/x/crypto v0.32.0/go.mod h1:ZnnJkOaASj8g0AjIduWNlq2NRxL0PlBrbKVyZ6V/Ugc=
+golang.org/x/image v0.23.0 h1:HseQ7c2OpPKTPVzNjG5fwJsOTCiiwS4QdsYi5XU6H68=
+golang.org/x/image v0.23.0/go.mod h1:wJJBTdLfCCf3tiHa1fNxpZmUI4mmoZvwMCPP0ddoNKY=
+golang.org/x/net v0.34.0 h1:Mb7Mrk043xzHgnRM88suvJFwzVrRfHEHJEl5/71CKw0=
+golang.org/x/net v0.34.0/go.mod h1:di0qlW3YNM5oh6GqDGQr92MyTozJPmybPK4Ev/Gm31k=
+golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.29.0 h1:TPYlXGxvx1MGTn2GiZDhnjPA9wZzZeGKHHmKhHYvgaU=
+golang.org/x/sys v0.29.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+google.golang.org/protobuf v1.36.4 h1:6A3ZDJHn/eNqc1i+IdefRzy/9PokBTPvcqMySR7NNIM=
+google.golang.org/protobuf v1.36.4/go.mod h1:9fA7Ob0pmnwhb644+1+CVWFRbNajQ6iRojtC/QF5bRE=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

slidge_whatsapp/group.py

@@ -0,0 +1,256 @@
+import re
+from datetime import datetime, timezone
+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 slixmpp.exceptions import XMPPError
+
+from .generated import go, whatsapp
+
+if TYPE_CHECKING:
+    from .contact import Contact
+    from .session import Session
+
+
+class Participant(LegacyParticipant):
+    contact: "Contact"
+    muc: "MUC"
+
+
+class MUC(LegacyMUC[str, str, Participant, str]):
+    session: "Session"
+    type = MucType.GROUP
+
+    HAS_DESCRIPTION = False
+    REACTIONS_SINGLE_EMOJI = True
+    _ALL_INFO_FILLED_ON_STARTUP = True
+
+    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)
+            elif avatar.URL == "":
+                await self.set_avatar(None)
+        except RuntimeError as err:
+            self.session.log.error(
+                "Failed getting avatar for group %s: %s", self.legacy_id, err
+            )
+
+    async def backfill(
+        self,
+        after: HoleBound | None = None,
+        before: HoleBound | None = None,
+    ):
+        """
+        Request history for messages older than the oldest message given by ID and date.
+        """
+
+        if before is None:
+            return
+            # WhatsApp requires a full reference to the last seen message in performing on-demand sync.
+
+        assert isinstance(before.id, str)
+        oldest_message = whatsapp.Message(
+            ID=before.id,
+            IsCarbon=self.session.message_is_carbon(self, before.id),
+            Timestamp=int(before.timestamp.timestamp()),
+        )
+        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:
+            raise XMPPError("internal-server-error", "Unable to find message sender")
+        msg = HistoryMessage(stored.stanza)
+        occupant_id = msg.stanza["occupant-id"]["id"]
+        if occupant_id == "slidge-user":
+            return self.session.contacts.user_legacy_id
+        if "@" in occupant_id:
+            jid_username = occupant_id.split("@")[0]
+            return jid_username.removeprefix("+") + "@" + whatsapp.DefaultUserServer
+        raise XMPPError("internal-server-error", "Unable to find message sender")
+
+    async def update_whatsapp_info(self, info: whatsapp.Group):
+        """
+        Set MUC information based on WhatsApp group information, which may or may not be partial in
+        case of updates to existing MUCs.
+        """
+        if info.Nickname:
+            self.user_nick = info.Nickname
+        if info.Name:
+            self.name = info.Name
+        if info.Subject.Subject:
+            self.subject = info.Subject.Subject
+            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
+        self.session.whatsapp_participants[self.legacy_id] = info.Participants
+
+    async def fill_participants(self) -> AsyncIterator[Participant]:
+        await self.session.bookmarks.ready
+        try:
+            participants = self.session.whatsapp_participants.pop(self.legacy_id)
+        except KeyError:
+            self.log.warning("No participants!")
+            return
+        for data in participants:
+            participant = await self.get_participant_by_legacy_id(data.JID)
+            if data.Action == whatsapp.GroupParticipantActionRemove:
+                self.remove_participant(participant)
+            else:
+                if data.Affiliation == whatsapp.GroupAffiliationAdmin:
+                    # Only owners can change the group name according to
+                    # XEP-0045, so we make all "WA admins" "XMPP owners"
+                    participant.affiliation = "owner"
+                    participant.role = "moderator"
+                elif data.Affiliation == whatsapp.GroupAffiliationOwner:
+                    # The WA owner is in fact the person who created the room
+                    participant.set_hats(
+                        [Hat("https://slidge.im/hats/slidge-whatsapp/owner", "Owner")]
+                    )
+                    participant.affiliation = "owner"
+                    participant.role = "moderator"
+                else:
+                    participant.affiliation = "member"
+                    participant.role = "participant"
+                yield participant
+
+    async def replace_mentions(self, t: str):
+        return replace_whatsapp_mentions(
+            t,
+            participants=(
+                {
+                    p.contact.jid_username: p.nickname
+                    async for p in self.get_participants()
+                    if p.contact is not None  # should not happen
+                }
+                | {self.session.user_phone: self.user_nick}
+                if self.session.user_phone  # user_phone *should* be set at this point,
+                else {}  # but better safe than sorry
+            ),
+        )
+
+    async def on_avatar(self, data: Optional[bytes], mime: Optional[str]) -> None:
+        return self.session.whatsapp.SetAvatar(
+            self.legacy_id,
+            go.Slice_byte.from_bytes(data) if data else go.Slice_byte(),
+        )
+
+    async def on_set_config(
+        self,
+        name: Optional[str],
+        description: Optional[str],
+    ):
+        # there are no group descriptions in WA, but topics=subjects
+        if self.name != name:
+            self.session.whatsapp.SetGroupName(self.legacy_id, name)
+
+    async def on_set_subject(self, subject: str):
+        if self.subject != subject:
+            self.session.whatsapp.SetGroupTopic(self.legacy_id, subject)
+
+    async def on_set_affiliation(
+        self,
+        contact: "Contact",  # type:ignore
+        affiliation: MucAffiliation,
+        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:
+                action = whatsapp.GroupParticipantActionAdd
+        elif affiliation == "admin":
+            action = whatsapp.GroupParticipantActionPromote
+        elif affiliation == "outcast" or affiliation == "none":
+            action = whatsapp.GroupParticipantActionRemove
+        else:
+            raise XMPPError(
+                "bad-request",
+                f"You can't make a participant '{affiliation}' in WhatsApp",
+            )
+        self.session.whatsapp.UpdateGroupParticipants(
+            self.legacy_id,
+            whatsapp.Slice_whatsapp_GroupParticipant(
+                [whatsapp.GroupParticipant(JID=contact.legacy_id, Action=action)]
+            ),
+        )
+
+
+class Bookmarks(LegacyBookmarks[str, MUC]):
+    session: "Session"
+
+    def __init__(self, session: "Session"):
+        super().__init__(session)
+        self.__filled = False
+
+    async def fill(self):
+        groups = self.session.whatsapp.GetGroups()
+        for group in groups:
+            await self.add_whatsapp_group(group)
+        self.__filled = True
+
+    async def add_whatsapp_group(self, data: whatsapp.Group):
+        muc = await self.by_legacy_id(data.JID)
+        await muc.update_whatsapp_info(data)
+        await muc.add_to_bookmarks()
+
+    async def legacy_id_to_jid_local_part(self, legacy_id: str):
+        return "#" + legacy_id[: legacy_id.find("@")]
+
+    async def jid_local_part_to_legacy_id(self, local_part: str):
+        if not local_part.startswith("#"):
+            raise XMPPError("bad-request", "Invalid group ID, expected '#' prefix")
+
+        if not self.__filled:
+            raise XMPPError(
+                "recipient-unavailable", "Still fetching group info, please retry later"
+            )
+
+        whatsapp_group_id = (
+            local_part.removeprefix("#") + "@" + whatsapp.DefaultGroupServer
+        )
+
+        if (
+            self.xmpp.store.rooms.get_by_legacy_id(
+                self.session.user_pk, whatsapp_group_id
+            )
+            is None
+        ):
+            raise XMPPError("item-not-found", f"No group found for {whatsapp_group_id}")
+
+        return whatsapp_group_id
+
+
+def replace_xmpp_mentions(text: str, mentions: list[Mention]):
+    offset: int = 0
+    result: str = ""
+    for m in mentions:
+        legacy_id = "@" + m.contact.legacy_id[: m.contact.legacy_id.find("@")]
+        result = result + text[offset : m.start] + legacy_id
+        offset = m.end
+    return result + text[offset:] if offset > 0 else text
+
+
+def replace_whatsapp_mentions(text: str, participants: dict[str, str]):
+    def match(m: re.Match):
+        group = m.group(0)
+        return participants.get(group.replace("@", "+"), group)
+
+    return re.sub(r"@\d+", match, text)

slidge_whatsapp/media/ffmpeg.go

@@ -0,0 +1,72 @@
+package media
+
+import (
+	// Standard library.
+	"bytes"
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"os/exec"
+)
+
+var (
+	// The full path and default arguments for FFmpeg, used for converting media to supported types.
+	ffmpegCommand, _  = exec.LookPath("ffmpeg")
+	ffmpegDefaultArgs = []string{"-v", "error", "-y"}
+
+	// The full path and default arguments for FFprobe, as provided by FFmpeg, used for getting media
+	// metadata (e.g. duration, waveforms, etc.)
+	ffprobeCommand, _  = exec.LookPath("ffprobe")
+	ffprobeDefaultArgs = []string{"-v", "error", "-of", "json=compact=1"}
+)
+
+// FFmpeg runs the `ffmpeg` command for the arguments provided, reading from the input file and
+// writing to the output file paths given.
+func ffmpeg(ctx context.Context, in, out string, args ...string) error {
+	if ffmpegCommand == "" {
+		return fmt.Errorf("FFmpeg command not found")
+	}
+
+	args = append(ffmpegDefaultArgs, append([]string{"-i", in}, append(args, out)...)...)
+	cmd := exec.CommandContext(ctx, ffmpegCommand, args...)
+
+	if _, err := cmd.Output(); err != nil {
+		if e := new(exec.ExitError); errors.As(err, &e) {
+			return fmt.Errorf("%s: %s", e.Error(), bytes.TrimSpace(e.Stderr))
+		}
+		return err
+	}
+
+	return nil
+}
+
+// FFprobe runs the `ffprobe` command for the arguments provided, reading from the input file given.
+// Depending on arguments provided, the result may be a deeply nested set of maps with no specific
+// structure; exploring the raw result of `ffprobe` commands with `-of json=compact=1` is recommended.
+func ffprobe(ctx context.Context, in string, args ...string) (map[string]any, error) {
+	if ffprobeCommand == "" {
+		return nil, fmt.Errorf("FFprobe command not found")
+	}
+
+	args = append(ffprobeDefaultArgs, append([]string{"-i", in}, args...)...)
+	cmd := exec.CommandContext(ctx, ffprobeCommand, args...)
+
+	stdout, err := cmd.StdoutPipe()
+	if err != nil {
+		return nil, fmt.Errorf("failed to set up standard output: %w", err)
+	} else if err = cmd.Start(); err != nil {
+		return nil, fmt.Errorf("failed to initialize FFprobe: %w", err)
+	}
+
+	out := make(map[string]any)
+	if err := json.NewDecoder(stdout).Decode(&out); err != nil {
+		return nil, fmt.Errorf("failed reading FFprobe output: %w", err)
+	}
+
+	if err = cmd.Wait(); err != nil {
+		return nil, fmt.Errorf("failed to wait for FFprobe command to complete: %w", err)
+	}
+
+	return out, nil
+}