Fix active group membership resolution

Author: domingogallardo

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "PyWABackupAPI"
-version = "0.1.0"
+version = "0.1.1"
 description = "Python port of SwiftWABackupAPI for exploring WhatsApp data in iPhone backups"
 readme = "README.md"
 requires-python = ">=3.11"

src/pywabackupapi/__init__.py

@@ -29,6 +29,8 @@
 )
 from .utils import canonical_json_dumps
 
+__version__ = "0.1.1"
+
 __all__ = [
     "BackupError",
     "BackupFetchResult",
@@ -57,5 +59,6 @@
     "UnsupportedSchemaError",
     "WABackup",
     "WABackupDelegate",
+    "__version__",
     "canonical_json_dumps",
 ]

src/pywabackupapi/api.py

@@ -435,6 +435,7 @@ class GroupMember:
 
     TABLE_NAME = "ZWAGROUPMEMBER"
     EXPECTED_COLUMNS = {"Z_PK", "ZMEMBERJID", "ZCONTACTNAME"}
+    ACTIVE_MEMBERSHIP_COLUMNS = {"ZCHATSESSION", "ZISACTIVE"}
 
     @classmethod
     def from_row(cls, row: sqlite3.Row) -> "GroupMember":
@@ -456,6 +457,25 @@ def fetch_group_member(cls, member_id: int, connection: sqlite3.Connection) -> "
         ).fetchone()
         return None if row is None else cls.from_row(row)
 
+    @classmethod
+    def fetch_active_group_members(cls, chat_id: int, connection: sqlite3.Connection) -> list["GroupMember"]:
+        rows = connection.execute(f"PRAGMA table_info({cls.TABLE_NAME})").fetchall()
+        column_names = {str(row["name"]).upper() for row in rows}
+        if not cls.ACTIVE_MEMBERSHIP_COLUMNS.issubset(column_names):
+            return []
+
+        rows = connection.execute(
+            f"""
+            SELECT *
+            FROM {cls.TABLE_NAME}
+            WHERE ZCHATSESSION = ?
+              AND IFNULL(ZISACTIVE, 0) = 1
+            ORDER BY Z_PK
+            """,
+            (chat_id,),
+        ).fetchall()
+        return [cls.from_row(row) for row in rows]
+
     @classmethod
     def fetch_group_member_ids(cls, chat_id: int, connection: sqlite3.Connection) -> list[int]:
         supported = SupportedMessageType.all_values()
@@ -1170,12 +1190,35 @@ def fetchGroupMemberInfo(
         group_member = GroupMember.fetch_group_member(memberId, connection)
         if group_member is None:
             return None
+        return self.fetchResolvedGroupMemberInfo(group_member, connection)
+
+    def fetchResolvedGroupMemberInfo(
+        self,
+        groupMember: GroupMember,
+        connection: sqlite3.Connection,
+    ) -> tuple[str | None, str | None]:
         return self.obtainSenderInfo(
-            jid=group_member.memberJid,
-            contactNameGroupMember=group_member.contactName,
+            jid=groupMember.memberJid,
+            contactNameGroupMember=groupMember.contactName,
             connection=connection,
         )
 
+    def fetchGroupContactMembers(
+        self,
+        chatId: int,
+        connection: sqlite3.Connection,
+    ) -> list[GroupMember]:
+        active_members = GroupMember.fetch_active_group_members(chatId, connection)
+        if active_members:
+            return active_members
+
+        members: list[GroupMember] = []
+        for member_id in GroupMember.fetch_group_member_ids(chatId, connection):
+            group_member = GroupMember.fetch_group_member(member_id, connection)
+            if group_member is not None:
+                members.append(group_member)
+        return members
+
     def fetchDuration(self, mediaItemId: int, connection: sqlite3.Connection) -> int | None:
         media_item = MediaItem.fetch_media_item(mediaItemId, connection)
         if media_item is None or media_item.movieDuration is None:
@@ -1311,14 +1354,31 @@ def obtainSenderInfo(
             lid_account = self.lidAccountIndex.account(jid)
             if lid_account is not None:
                 profile_display_name = normalized_author_field(ProfilePushName.push_name(jid, connection))
+                linked_phone_jid = self.linkedPhoneJid(jid) or self.lidAccountIndex.phoneJid(jid)
+                linked_phone_display_name: str | None = None
+                if linked_phone_jid is not None:
+                    linked_phone_display_name = self.resolvedContactDisplayName(
+                        jid=linked_phone_jid,
+                        profileDisplayName=normalized_author_field(ProfilePushName.push_name(linked_phone_jid, connection)),
+                        senderPhone=normalized_author_field(extracted_phone(linked_phone_jid)),
+                        connection=connection,
+                    )
                 return (
-                    profile_display_name,
+                    linked_phone_display_name or profile_display_name,
                     normalized_author_field(lid_account.normalizedPhoneNumber) or sender_phone,
                 )
 
         linked_phone_jid = self.linkedPhoneJid(jid)
         if linked_phone_jid is not None:
-            return (None, normalized_author_field(extracted_phone(linked_phone_jid)))
+            return (
+                self.resolvedContactDisplayName(
+                    jid=linked_phone_jid,
+                    profileDisplayName=normalized_author_field(ProfilePushName.push_name(linked_phone_jid, connection)),
+                    senderPhone=normalized_author_field(extracted_phone(linked_phone_jid)),
+                    connection=connection,
+                ),
+                normalized_author_field(extracted_phone(linked_phone_jid)),
+            )
 
         push_name = ProfilePushName.push_name(jid, connection)
         if push_name is not None:
@@ -1329,6 +1389,26 @@ def obtainSenderInfo(
 
         return (contactNameGroupMember, sender_phone)
 
+    def resolvedContactDisplayName(
+        self,
+        jid: str,
+        profileDisplayName: str | None,
+        senderPhone: str | None,
+        connection: sqlite3.Connection,
+    ) -> str | None:
+        chat_session_name = normalized_author_field(ChatSession.fetch_chat_session_name(jid, connection))
+        if chat_session_name is not None and not self.isPhoneLikeDisplayLabel(chat_session_name, senderPhone):
+            return chat_session_name
+
+        if self.addressBookIndex is not None:
+            address_book_contact = self.addressBookIndex.contact(jid)
+            if address_book_contact is not None:
+                display_name = normalized_author_field(address_book_contact.bestDisplayName)
+                if display_name is not None:
+                    return display_name
+
+        return profileDisplayName
+
     def makeParticipantAuthor(
         self,
         jid: str,
@@ -1525,14 +1605,13 @@ def buildContactList(
                     other_contact = self.copyContactMedia(other_contact, backup, directory)
                 contacts.append(other_contact)
         else:
-            for member_id in GroupMember.fetch_group_member_ids(chatInfo.id, connection):
-                sender_info = self.fetchGroupMemberInfo(member_id, connection)
-                if sender_info is None:
-                    continue
-                sender_name, sender_phone = sender_info
-                if sender_phone is None or sender_phone == owner_phone:
+            seen_phones = {owner_phone}
+            for member in self.fetchGroupContactMembers(chatInfo.id, connection):
+                sender_name, sender_phone = self.fetchResolvedGroupMemberInfo(member, connection)
+                if sender_phone is None or sender_phone == owner_phone or sender_phone in seen_phones:
                     continue
-                contact = ContactInfo(name=sender_name or "", phone=sender_phone)
+                seen_phones.add(sender_phone)
+                contact = ContactInfo(name=sender_name or sender_phone, phone=sender_phone)
                 if directory is not None:
                     contact = self.copyContactMedia(contact, backup, directory)
                 contacts.append(contact)

tests/support.py

@@ -848,6 +848,154 @@ def setup(connection: sqlite3.Connection) -> None:
     return wa_backup, fixture
 
 
+def make_connected_active_group_members_backup() -> tuple[WABackup, TemporaryBackupFixture]:
+    def setup(connection: sqlite3.Connection) -> None:
+        create_common_tables(connection)
+        connection.execute("ALTER TABLE ZWAGROUPMEMBER ADD COLUMN ZISACTIVE INTEGER")
+        connection.execute("ALTER TABLE ZWAGROUPMEMBER ADD COLUMN ZCHATSESSION INTEGER")
+
+        latest = reference_date_timestamp(2024, 4, 11, 11, 0, 0)
+        connection.execute(
+            """
+            INSERT INTO ZWACHATSESSION
+            (Z_PK, ZCONTACTJID, ZPARTNERNAME, ZLASTMESSAGEDATE, ZMESSAGECOUNTER, ZSESSIONTYPE, ZARCHIVED)
+            VALUES (?, ?, ?, ?, ?, ?, ?)
+            """,
+            (710, "08185296380-999999@g.us", "Active Member Group", latest, 3, 0, 0),
+        )
+        connection.execute(
+            """
+            INSERT INTO ZWACHATSESSION
+            (Z_PK, ZCONTACTJID, ZPARTNERNAME, ZLASTMESSAGEDATE, ZMESSAGECOUNTER, ZSESSIONTYPE, ZARCHIVED)
+            VALUES (?, ?, ?, ?, ?, ?, ?)
+            """,
+            (711, "08185296380@s.whatsapp.net", "Me", latest, 1, 0, 0),
+        )
+
+        historical_members = [
+            (901, "08185296378@s.whatsapp.net", "Alice Historical", 0, 710),
+            (902, "40482648261001@lid", None, 0, 710),
+        ]
+        connection.executemany(
+            """
+            INSERT INTO ZWAGROUPMEMBER (Z_PK, ZMEMBERJID, ZCONTACTNAME, ZISACTIVE, ZCHATSESSION)
+            VALUES (?, ?, ?, ?, ?)
+            """,
+            historical_members,
+        )
+
+        active_members = [
+            (911, "08185296380@s.whatsapp.net", None, 1, 710),
+            (912, "08185296378@s.whatsapp.net", "Alice Active", 1, 710),
+            (913, "40482648261001@lid", None, 1, 710),
+            (914, "40482648261002@lid", None, 1, 710),
+        ]
+        connection.executemany(
+            """
+            INSERT INTO ZWAGROUPMEMBER (Z_PK, ZMEMBERJID, ZCONTACTNAME, ZISACTIVE, ZCHATSESSION)
+            VALUES (?, ?, ?, ?, ?)
+            """,
+            active_members,
+        )
+
+        push_names = [
+            ("Linked Delta", "08185296371@s.whatsapp.net"),
+            ("Nova Member", "08185296390@s.whatsapp.net"),
+        ]
+        connection.executemany(
+            "INSERT INTO ZWAPROFILEPUSHNAME (ZPUSHNAME, ZJID) VALUES (?, ?)",
+            push_names,
+        )
+
+        messages = [
+            (
+                710001,
+                "08185296380-999999@g.us",
+                0,
+                901,
+                710,
+                "Historical Alice message",
+                reference_date_timestamp(2024, 4, 11, 10, 0, 0),
+                "08185296378@s.whatsapp.net",
+                None,
+                0,
+                None,
+                "active-group-1",
+            ),
+            (
+                710002,
+                "08185296380-999999@g.us",
+                0,
+                902,
+                710,
+                "Historical Delta message",
+                reference_date_timestamp(2024, 4, 11, 10, 5, 0),
+                "40482648261001@lid",
+                None,
+                0,
+                None,
+                "active-group-2",
+            ),
+            (
+                710003,
+                "08185296380-999999@g.us",
+                0,
+                None,
+                710,
+                "Outgoing",
+                latest,
+                None,
+                None,
+                1,
+                None,
+                "active-group-3",
+            ),
+            (
+                711001,
+                "08185296380@s.whatsapp.net",
+                6,
+                None,
+                711,
+                None,
+                reference_date_timestamp(2024, 4, 11, 9, 0, 0),
+                None,
+                None,
+                1,
+                None,
+                "active-group-owner",
+            ),
+        ]
+        connection.executemany(
+            """
+            INSERT INTO ZWAMESSAGE
+            (Z_PK, ZTOJID, ZMESSAGETYPE, ZGROUPMEMBER, ZCHATSESSION, ZTEXT, ZMESSAGEDATE, ZFROMJID, ZMEDIAITEM, ZISFROMME, ZGROUPEVENTTYPE, ZSTANZAID)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            """,
+            messages,
+        )
+
+    fixture = make_temporary_backup(name="active-group-members-backup", chat_storage_setup=setup)
+
+    add_lid_database(
+        fixture,
+        setup=lambda connection: connection.executemany(
+            """
+            INSERT INTO ZWAZACCOUNT
+            (Z_PK, ZIDENTIFIER, ZPHONENUMBER, ZCREATEDAT)
+            VALUES (?, ?, ?, ?)
+            """,
+            [
+                (1, "40482648261001@lid", "08185296371", reference_date_timestamp(2025, 2, 10, 12, 0, 0)),
+                (2, "40482648261002@lid", "08185296390", reference_date_timestamp(2025, 2, 10, 12, 1, 0)),
+            ],
+        ),
+    )
+
+    wa_backup = WABackup(backupPath=str(fixture.rootURL))
+    wa_backup.connectChatStorageDb(fixture.backup)
+    return wa_backup, fixture
+
+
 def make_connected_incomplete_location_backup() -> tuple[WABackup, TemporaryBackupFixture]:
     def setup(connection: sqlite3.Connection) -> None:
         create_common_tables(connection)

tests/test_public.py

@@ -27,6 +27,7 @@
     MediaWriteDelegateSpy,
     add_lid_database,
     canonical_json,
+    make_connected_active_group_members_backup,
     make_connected_filtered_chat_backup,
     make_connected_group_backup,
     make_connected_incomplete_location_backup,
@@ -561,3 +562,24 @@ def test_group_contact_list_contains_owner_and_distinct_members() -> None:
         assert len([contact for contact in dump.contacts if contact.name == "Me"]) == 1
     finally:
         remove_item_if_exists(fixture.rootURL)
+
+
+def test_group_contact_list_prefers_active_membership_and_deduplicates_history() -> None:
+    wa_backup, fixture = make_connected_active_group_members_backup()
+    try:
+        dump = wa_backup.getChat(chatId=710, directoryToSaveMedia=None)
+        contacts_by_phone = {contact.phone: contact for contact in dump.contacts}
+
+        assert len(dump.contacts) == 4
+        assert set(contacts_by_phone) == {
+            "08185296380",
+            "08185296378",
+            "08185296371",
+            "08185296390",
+        }
+        assert contacts_by_phone["08185296380"].name == "Me"
+        assert contacts_by_phone["08185296378"].name == "Alice Active"
+        assert contacts_by_phone["08185296371"].name == "Linked Delta"
+        assert contacts_by_phone["08185296390"].name == "Nova Member"
+    finally:
+        remove_item_if_exists(fixture.rootURL)