tessl/pypi-line-bot-sdk

LINE Messaging API SDK for Python with comprehensive bot development capabilities including messaging, webhooks, and platform integrations.

—

Pending

Overview

Eval results

Files

User and Profile Management

Name: tessl/pypi-line-bot-sdk
Author: tessl

User profile access, group and room management, follower insights, and membership features. This module provides comprehensive user interaction capabilities including profile retrieval, group management, and follower analytics.

Capabilities

User Profile Management

Access detailed user profile information and interaction history.

class MessagingApi:
    def get_profile(self, user_id: str) -> UserProfileResponse:
        """
        Get user profile information including display name and profile picture.
        
        Args:
            user_id: LINE user ID
            
        Returns:
            UserProfileResponse: User profile data
        """
        
    def get_group_member_profile(self, group_id: str, user_id: str) -> GroupUserProfileResponse:
        """
        Get user profile within a specific group context.
        
        Args:
            group_id: LINE group ID
            user_id: LINE user ID within the group
            
        Returns:
            GroupUserProfileResponse: User profile in group context
        """
        
    def get_room_member_profile(self, room_id: str, user_id: str) -> RoomUserProfileResponse:
        """
        Get user profile within a specific room context.
        
        Args:
            room_id: LINE room ID
            user_id: LINE user ID within the room
            
        Returns:
            RoomUserProfileResponse: User profile in room context
        """

Group Management

Manage group chats including member access and group information retrieval.

class MessagingApi:
    def get_group_summary(self, group_id: str) -> GroupSummaryResponse:
        """
        Get group information including name and member count.
        
        Args:
            group_id: LINE group ID
            
        Returns:
            GroupSummaryResponse: Group metadata and information
        """
        
    def get_group_members_count(self, group_id: str) -> GroupMemberCountResponse:
        """
        Get total number of members in a group.
        
        Args:
            group_id: LINE group ID
            
        Returns:
            GroupMemberCountResponse: Member count information
        """
        
    def get_group_member_user_ids(self, group_id: str, start: Optional[str] = None) -> MembersIdsResponse:
        """
        Get user IDs of group members with pagination.
        
        Args:
            group_id: LINE group ID
            start: Pagination start token
            
        Returns:
            MembersIdsResponse: Member user IDs and pagination info
        """
        
    def leave_group(self, group_id: str) -> dict:
        """
        Make the bot leave a group chat.
        
        Args:
            group_id: LINE group ID to leave
            
        Returns:
            dict: Empty response on success
        """

Room Management

Manage room chats with member access and room information retrieval.

class MessagingApi:
    def get_room_member_count(self, room_id: str) -> RoomMemberCountResponse:
        """
        Get total number of members in a room.
        
        Args:
            room_id: LINE room ID
            
        Returns:
            RoomMemberCountResponse: Member count information
        """
        
    def get_room_member_user_ids(self, room_id: str, start: Optional[str] = None) -> MembersIdsResponse:
        """
        Get user IDs of room members with pagination.
        
        Args:
            room_id: LINE room ID
            start: Pagination start token
            
        Returns:
            MembersIdsResponse: Member user IDs and pagination info
        """
        
    def leave_room(self, room_id: str) -> dict:
        """
        Make the bot leave a room chat.
        
        Args:
            room_id: LINE room ID to leave
            
        Returns:
            dict: Empty response on success
        """

Follower Management

Access follower information and manage follower relationships.

class MessagingApi:
    def get_followers(self, start: Optional[str] = None, limit: Optional[int] = None) -> GetFollowersResponse:
        """
        Get list of users who follow the bot with pagination.
        
        Args:
            start: Pagination start token
            limit: Maximum number of followers to return (max 300)
            
        Returns:
            GetFollowersResponse: Follower user IDs and pagination info
        """
        
    def get_bot_info(self) -> BotInfoResponse:
        """
        Get bot information including display name and settings.
        
        Returns:
            BotInfoResponse: Bot profile and configuration data
        """

Membership Management

Handle membership features for premium LINE services and subscriptions.

class MessagingApi:
    def get_membership_subscription(self, user_id: str) -> GetMembershipSubscriptionResponse:
        """
        Get user's membership subscription information.
        
        Args:
            user_id: LINE user ID
            
        Returns:
            GetMembershipSubscriptionResponse: Subscription details and status
        """
        
    def get_memberships(self) -> MembershipListResponse:
        """
        Get list of available memberships for the bot.
        
        Returns:
            MembershipListResponse: Available membership plans
        """
        
    def get_joined_membership_users(
        self,
        membership_id: str,
        start: Optional[str] = None,
        limit: Optional[int] = None
    ) -> GetJoinedMembershipUsersResponse:
        """
        Get users who have joined a specific membership.
        
        Args:
            membership_id: Membership plan identifier
            start: Pagination start token
            limit: Maximum number of users to return
            
        Returns:
            GetJoinedMembershipUsersResponse: Member users and pagination info
        """

Message Reading Management

Manage message read status and user interaction tracking.

class MessagingApi:
    def mark_messages_as_read(self, mark_messages_as_read_request: MarkMessagesAsReadRequest) -> dict:
        """
        Mark messages as read for chat management.
        
        Args:
            mark_messages_as_read_request: Messages to mark as read
            
        Returns:
            dict: Empty response on success
        """

User Management Models

Profile Response Models

class UserProfileResponse:
    display_name: str
    user_id: str
    language: str
    picture_url: Optional[str] = None
    status_message: Optional[str] = None

class GroupUserProfileResponse:
    display_name: str
    user_id: str
    picture_url: Optional[str] = None

class RoomUserProfileResponse:
    display_name: str
    user_id: str
    picture_url: Optional[str] = None

Group and Room Models

class GroupSummaryResponse:
    group_id: str
    group_name: str
    picture_url: Optional[str] = None

class GroupMemberCountResponse:
    count: int

class RoomMemberCountResponse:
    count: int

class MembersIdsResponse:
    member_ids: List[str]
    next: Optional[str] = None

Follower Models

class GetFollowersResponse:
    user_ids: List[str]
    next: Optional[str] = None

class BotInfoResponse:
    basic_id: str
    premium_id: Optional[str] = None
    display_name: str
    picture_url: Optional[str] = None
    chat_mode: str
    mark_as_read_mode: str

Membership Models

class GetMembershipSubscriptionResponse:
    memberships: List[Membership]
    next: Optional[str] = None

class Membership:
    membership_id: str
    subscription_id: str
    title: str
    description: str
    image_url: Optional[str] = None
    premium_id: str

class MembershipListResponse:
    memberships: List[Membership]

class GetJoinedMembershipUsersResponse:
    users: List[SubscribedMembershipUser]
    next: Optional[str] = None

class SubscribedMembershipUser:
    user_id: str
    subscription: Subscription

class Subscription:
    subscription_id: str
    membership_id: str
    plan: SubscribedMembershipPlan

class SubscribedMembershipPlan:
    plan_id: str
    title: str
    description: str

Message Management Models

class MarkMessagesAsReadRequest:
    def __init__(self, chat_id: str):
        """
        Request to mark messages as read in a chat.
        
        Args:
            chat_id: Chat identifier (user, group, or room ID)
        """
        self.chat_id = chat_id

Usage Examples

Basic User Profile Access

from linebot.v3.messaging import MessagingApi, Configuration

# Initialize API client
config = Configuration(access_token='YOUR_ACCESS_TOKEN')
messaging_api = MessagingApi(config)

# Get user profile
try:
    profile = messaging_api.get_profile("USER_ID_HERE")
    print(f"User: {profile.display_name}")
    print(f"Language: {profile.language}")
    if profile.picture_url:
        print(f"Profile Picture: {profile.picture_url}")
    if profile.status_message:
        print(f"Status: {profile.status_message}")
except Exception as e:
    print(f"Failed to get profile: {e}")

Group Management

# Get group information
group_id = "GROUP_ID_HERE"

# Basic group info
group_info = messaging_api.get_group_summary(group_id)
print(f"Group: {group_info.group_name}")

# Member count
member_count = messaging_api.get_group_members_count(group_id)
print(f"Members: {member_count.count}")

# Get member list with pagination
members_response = messaging_api.get_group_member_user_ids(group_id)
print(f"Member IDs: {members_response.member_ids}")

# Get more members if available
if members_response.next:
    more_members = messaging_api.get_group_member_user_ids(
        group_id, 
        start=members_response.next
    )
    print(f"Additional members: {more_members.member_ids}")

# Get individual member profiles
for user_id in members_response.member_ids[:5]:  # First 5 members
    try:
        member_profile = messaging_api.get_group_member_profile(group_id, user_id)
        print(f"Member: {member_profile.display_name} ({user_id})")
    except Exception as e:
        print(f"Could not get profile for {user_id}: {e}")

Follower Analytics

# Get bot information
bot_info = messaging_api.get_bot_info()
print(f"Bot Name: {bot_info.display_name}")
print(f"Basic ID: {bot_info.basic_id}")
print(f"Chat Mode: {bot_info.chat_mode}")

# Get follower list with pagination
def get_all_followers():
    all_followers = []
    start_token = None
    
    while True:
        response = messaging_api.get_followers(start=start_token, limit=300)
        all_followers.extend(response.user_ids)
        
        if not response.next:
            break
        start_token = response.next
    
    return all_followers

followers = get_all_followers()
print(f"Total followers: {len(followers)}")

# Get follower profiles (sample)
for user_id in followers[:10]:  # First 10 followers
    try:
        profile = messaging_api.get_profile(user_id)
        print(f"Follower: {profile.display_name} - {profile.language}")
    except Exception as e:
        print(f"Could not get profile for {user_id}: {e}")

Room Management

room_id = "ROOM_ID_HERE"

# Get room member count
room_count = messaging_api.get_room_member_count(room_id)
print(f"Room members: {room_count.count}")

# Get room member IDs
room_members = messaging_api.get_room_member_user_ids(room_id)
print(f"Room member IDs: {room_members.member_ids}")

# Get room member profiles
for user_id in room_members.member_ids:
    try:
        member_profile = messaging_api.get_room_member_profile(room_id, user_id)
        print(f"Room member: {member_profile.display_name}")
    except Exception as e:
        print(f"Could not get room profile for {user_id}: {e}")

# Leave room if needed
# messaging_api.leave_room(room_id)

Membership Management

# Get available memberships
memberships = messaging_api.get_memberships()
print(f"Available memberships: {len(memberships.memberships)}")

for membership in memberships.memberships:
    print(f"Membership: {membership.title}")
    print(f"Description: {membership.description}")
    
    # Get users who joined this membership
    joined_users = messaging_api.get_joined_membership_users(membership.membership_id)
    print(f"Joined users: {len(joined_users.users)}")

# Check specific user's membership
user_id = "USER_ID_HERE"
try:
    user_memberships = messaging_api.get_membership_subscription(user_id)
    print(f"User memberships: {len(user_memberships.memberships)}")
    
    for membership in user_memberships.memberships:
        print(f"User has membership: {membership.title}")
except Exception as e:
    print(f"Could not get user memberships: {e}")

Advanced User Analytics

from collections import Counter
import time

class UserAnalytics:
    def __init__(self, messaging_api: MessagingApi):
        self.api = messaging_api
    
    def analyze_follower_languages(self):
        """Analyze follower language distribution."""
        followers = self.get_all_followers()
        languages = []
        
        # Rate limit: get profiles with delays
        for i, user_id in enumerate(followers):
            try:
                profile = self.api.get_profile(user_id)
                languages.append(profile.language)
                
                # Avoid rate limiting
                if i % 50 == 0:
                    time.sleep(1)
                    
            except Exception as e:
                print(f"Could not get profile for {user_id}: {e}")
                continue
        
        # Analyze language distribution
        language_counts = Counter(languages)
        print("Follower language distribution:")
        for lang, count in language_counts.most_common():
            percentage = (count / len(languages)) * 100
            print(f"{lang}: {count} ({percentage:.1f}%)")
        
        return language_counts
    
    def analyze_group_activity(self, group_id: str):
        """Analyze group member activity and profiles."""
        group_info = self.api.get_group_summary(group_id)
        member_count = self.api.get_group_members_count(group_id)
        
        print(f"Group Analysis: {group_info.group_name}")
        print(f"Total members: {member_count.count}")
        
        # Get member profiles
        members = self.api.get_group_member_user_ids(group_id)
        active_members = 0
        
        for user_id in members.member_ids:
            try:
                # Get both group profile and general profile
                group_profile = self.api.get_group_member_profile(group_id, user_id)
                general_profile = self.api.get_profile(user_id)
                
                print(f"Member: {group_profile.display_name}")
                print(f"  Language: {general_profile.language}")
                active_members += 1
                
            except Exception as e:
                # User might have blocked the bot or left
                continue
        
        print(f"Accessible member profiles: {active_members}/{len(members.member_ids)}")
        return {
            'total_members': member_count.count,
            'accessible_members': active_members,
            'group_name': group_info.group_name
        }
    
    def get_all_followers(self):
        """Get all follower IDs with pagination."""
        all_followers = []
        start_token = None
        
        while True:
            try:
                response = self.api.get_followers(start=start_token, limit=300)
                all_followers.extend(response.user_ids)
                
                if not response.next:
                    break
                start_token = response.next
                
            except Exception as e:
                print(f"Error fetching followers: {e}")
                break
        
        return all_followers

# Usage
analytics = UserAnalytics(messaging_api)
language_distribution = analytics.analyze_follower_languages()

Message Reading Management

from linebot.v3.messaging.models import MarkMessagesAsReadRequest

# Mark messages as read in a chat
def mark_chat_as_read(chat_id: str):
    """Mark all messages in a chat as read."""
    try:
        request = MarkMessagesAsReadRequest(chat_id=chat_id)
        messaging_api.mark_messages_as_read(request)
        print(f"Marked messages as read for chat: {chat_id}")
    except Exception as e:
        print(f"Failed to mark messages as read: {e}")

# Mark messages as read for multiple chats
def mark_multiple_chats_as_read(chat_ids: list):
    """Mark messages as read for multiple chats."""
    for chat_id in chat_ids:
        mark_chat_as_read(chat_id)
        time.sleep(0.1)  # Small delay to avoid rate limiting

Install with Tessl CLI