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

Core Messaging

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

Core messaging functionality for sending messages through the LINE platform including push messages, reply messages, multicast, broadcast, and user profile management. This module provides the essential capabilities for bot communication and user interaction.

Capabilities

Message Sending

Send messages to users through various delivery methods including direct push, reply to events, multicast to multiple users, and broadcast to all followers.

class MessagingApi:
    def reply_message(self, reply_message_request: ReplyMessageRequest) -> ReplyMessageResponse:
        """
        Reply to user messages or events using reply tokens.
        
        Args:
            reply_message_request: Reply message configuration with token and messages
            
        Returns:
            ReplyMessageResponse: Sent message metadata
        """
        
    def push_message(self, push_message_request: PushMessageRequest) -> PushMessageResponse:
        """
        Send messages directly to users without reply tokens.
        
        Args:
            push_message_request: Push message configuration with recipient and messages
            
        Returns:
            PushMessageResponse: Sent message metadata
        """
        
    def multicast(self, multicast_request: MulticastRequest) -> dict:
        """
        Send messages to multiple specific users.
        
        Args:
            multicast_request: Multicast configuration with user IDs and messages
            
        Returns:
            dict: Empty response on success
        """
        
    def broadcast(self, broadcast_request: BroadcastRequest) -> dict:
        """
        Send messages to all bot followers.
        
        Args:
            broadcast_request: Broadcast configuration with messages and filters
            
        Returns:
            dict: Empty response on success
        """

    def narrowcast(self, narrowcast_request: NarrowcastRequest) -> dict:
        """
        Send targeted messages to specific audience segments.
        
        Args:
            narrowcast_request: Narrowcast configuration with audience and messages
            
        Returns:
            dict: Empty response on success
        """

Message Validation

Validate message objects before sending to ensure proper formatting and compliance with LINE platform requirements.

class MessagingApi:
    def validate_reply_message_objects(self, validate_message_request: ValidateMessageRequest) -> dict:
        """Validate reply message objects for proper formatting."""
        
    def validate_push_message_objects(self, validate_message_request: ValidateMessageRequest) -> dict:
        """Validate push message objects for proper formatting."""
        
    def validate_multicast_message_objects(self, validate_message_request: ValidateMessageRequest) -> dict:
        """Validate multicast message objects for proper formatting."""
        
    def validate_broadcast_message_objects(self, validate_message_request: ValidateMessageRequest) -> dict:
        """Validate broadcast message objects for proper formatting."""
        
    def validate_narrowcast_message_objects(self, validate_message_request: ValidateMessageRequest) -> dict:
        """Validate narrowcast message objects for proper formatting."""

User Profile Management

Access user profile information, group and room details, and manage user interactions.

class MessagingApi:
    def get_profile(self, user_id: str) -> UserProfileResponse:
        """
        Get user profile information.
        
        Args:
            user_id: LINE user ID
            
        Returns:
            UserProfileResponse: User profile data including display name and picture
        """
        
    def get_group_summary(self, group_id: str) -> GroupSummaryResponse:
        """
        Get group information and member count.
        
        Args:
            group_id: LINE group ID
            
        Returns:
            GroupSummaryResponse: Group metadata and member information
        """
        
    def get_group_members_count(self, group_id: str) -> GroupMemberCountResponse:
        """Get total member count in a group."""
        
    def get_group_member_profile(self, group_id: str, user_id: str) -> GroupUserProfileResponse:
        """Get user profile within a specific group context."""
        
    def get_room_member_count(self, room_id: str) -> RoomMemberCountResponse:
        """Get total member count in a room."""
        
    def get_room_member_profile(self, room_id: str, user_id: str) -> RoomUserProfileResponse:
        """Get user profile within a specific room context."""

Bot Information

Retrieve bot-specific information and configuration details.

class MessagingApi:
    def get_bot_info(self) -> BotInfoResponse:
        """
        Get bot profile information including display name, user ID, and basic settings.
        
        Returns:
            BotInfoResponse: Bot profile metadata
        """

Message Content and Media

Handle message content retrieval and transcoding for media messages.

class MessagingApiBlob:
    def get_message_content(self, message_id: str) -> bytes:
        """
        Retrieve binary content from media messages.
        
        Args:
            message_id: Message ID containing media content
            
        Returns:
            bytes: Binary content data
        """
        
    def get_message_content_preview(self, message_id: str) -> bytes:
        """Get preview/thumbnail version of media content."""
        
    def get_message_content_transcoding_by_message_id(self, message_id: str) -> GetMessageContentTranscodingResponse:
        """Get transcoding status and information for video content."""

Message Quota Management

Monitor and manage message quota usage and consumption.

class MessagingApi:
    def get_message_quota(self) -> MessageQuotaResponse:
        """
        Get current message quota limits and usage.
        
        Returns:
            MessageQuotaResponse: Quota limits and consumption data
        """
        
    def get_message_quota_consumption(self) -> QuotaConsumptionResponse:
        """Get detailed message quota consumption statistics."""

Message Statistics

Access message delivery statistics and performance metrics.

class MessagingApi:
    def get_number_of_sent_reply_messages(self, date: str) -> NumberOfMessagesResponse:
        """Get count of reply messages sent on specific date."""
        
    def get_number_of_sent_push_messages(self, date: str) -> NumberOfMessagesResponse:
        """Get count of push messages sent on specific date."""
        
    def get_number_of_sent_multicast_messages(self, date: str) -> NumberOfMessagesResponse:
        """Get count of multicast messages sent on specific date."""
        
    def get_number_of_sent_broadcast_messages(self, date: str) -> NumberOfMessagesResponse:
        """Get count of broadcast messages sent on specific date."""

Loading Animation

Show loading animations to users during processing.

class MessagingApi:
    def show_loading_animation(self, show_loading_animation_request: ShowLoadingAnimationRequest) -> dict:
        """
        Display loading animation to user while processing requests.
        
        Args:
            show_loading_animation_request: Configuration for loading animation display
            
        Returns:
            dict: Empty response on success
        """

Message Reading Management

Mark messages as read to improve user experience and chat organization.

class MessagingApi:
    def mark_messages_as_read(self, mark_messages_as_read_request: MarkMessagesAsReadRequest) -> dict:
        """
        Mark messages as read in one-on-one, group, or room chat.
        
        Args:
            mark_messages_as_read_request: Configuration with chat reference and message details
            
        Returns:
            dict: Empty response on success
        """

Link Token Management

Issue link tokens for account linking functionality.

class MessagingApi:
    def issue_link_token(self, user_id: str) -> IssueLinkTokenResponse:
        """
        Issue a link token for account linking with external services.
        
        Args:
            user_id: User ID for the LINE account to be linked
            
        Returns:
            IssueLinkTokenResponse: Link token for account linking
        """

Group and Room Management

Leave groups and rooms when needed for bot management.

class MessagingApi:
    def leave_group(self, group_id: str) -> dict:
        """
        Leave a group chat.
        
        Args:
            group_id: Group ID to leave
            
        Returns:
            dict: Empty response on success
        """
        
    def leave_room(self, room_id: str) -> dict:
        """
        Leave a room chat.
        
        Args:
            room_id: Room ID to leave
            
        Returns:
            dict: Empty response on success
        """
        
    def get_group_members_ids(self, group_id: str, start: Optional[str] = None) -> MembersIdsResponse:
        """
        Get list of user IDs of members in a group.
        
        Args:
            group_id: Group ID
            start: Continuation token for pagination
            
        Returns:
            MembersIdsResponse: List of member IDs and next token
        """
        
    def get_room_members_ids(self, room_id: str, start: Optional[str] = None) -> MembersIdsResponse:
        """
        Get list of user IDs of members in a room.
        
        Args:
            room_id: Room ID
            start: Continuation token for pagination
            
        Returns:
            MembersIdsResponse: List of member IDs and next token
        """

Webhook Endpoint Management

Manage webhook endpoints for receiving LINE platform events.

class MessagingApi:
    def get_webhook_endpoint(self) -> GetWebhookEndpointResponse:
        """
        Get the current webhook endpoint URL.
        
        Returns:
            GetWebhookEndpointResponse: Current webhook endpoint configuration
        """
        
    def set_webhook_endpoint(self, set_webhook_endpoint_request: SetWebhookEndpointRequest) -> dict:
        """
        Set the webhook endpoint URL.
        
        Args:
            set_webhook_endpoint_request: New webhook endpoint configuration
            
        Returns:
            dict: Empty response on success
        """
        
    def test_webhook_endpoint(self, test_webhook_endpoint_request: TestWebhookEndpointRequest) -> TestWebhookEndpointResponse:
        """
        Test the webhook endpoint configuration.
        
        Args:
            test_webhook_endpoint_request: Test webhook configuration
            
        Returns:
            TestWebhookEndpointResponse: Test results and status
        """

Request and Response Models

Request Models

class ReplyMessageRequest:
    reply_token: str
    messages: List[Message]
    notification_disabled: Optional[bool] = None

class PushMessageRequest:
    to: str  # User ID, group ID, or room ID
    messages: List[Message]
    notification_disabled: Optional[bool] = None
    custom_aggregation_units: Optional[List[str]] = None

class MulticastRequest:
    to: List[str]  # List of user IDs
    messages: List[Message]
    notification_disabled: Optional[bool] = None
    custom_aggregation_units: Optional[List[str]] = None

class BroadcastRequest:
    messages: List[Message]
    notification_disabled: Optional[bool] = None
    custom_aggregation_units: Optional[List[str]] = None

class NarrowcastRequest:
    messages: List[Message]
    recipient: Recipient
    filter: Optional[Filter] = None
    limit: Optional[Limit] = None
    notification_disabled: Optional[bool] = None

class ValidateMessageRequest:
    messages: List[Message]

class MarkMessagesAsReadRequest:
    chat_reference: ChatReference

class SetWebhookEndpointRequest:
    endpoint: str

class TestWebhookEndpointRequest:
    endpoint: str

Response Models

class ReplyMessageResponse:
    sent_messages: List[SentMessage]

class PushMessageResponse:
    sent_messages: List[SentMessage]

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

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

class GroupMemberCountResponse:
    count: int

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

class MessageQuotaResponse:
    type: QuotaType
    value: int

class NumberOfMessagesResponse:
    status: str
    success: Optional[int] = None

class IssueLinkTokenResponse:
    link_token: str

class GetWebhookEndpointResponse:
    endpoint: str
    active: bool

class TestWebhookEndpointResponse:
    success: bool
    timestamp: str
    status_code: int
    reason: str
    detail: str

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

class ChatReference:
    type: str  # "user", "group", or "room"
    id: str

Sent Message Models

class SentMessage:
    id: str
    quota_consumption: Optional[int] = None

class QuotaType:
    """Enum for quota types: none, limited"""
    pass

Usage Examples

Basic Message Sending

from linebot.v3.messaging import MessagingApi, Configuration
from linebot.v3.messaging.models import TextMessage, ReplyMessageRequest

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

# Reply to a message event
reply_request = ReplyMessageRequest(
    reply_token=event.reply_token,
    messages=[TextMessage(text="Hello, World!")]
)
response = messaging_api.reply_message(reply_request)

# Push message to specific user
push_request = PushMessageRequest(
    to="USER_ID_HERE",
    messages=[TextMessage(text="Push notification message")]
)
messaging_api.push_message(push_request)

Multicast to Multiple Users

from linebot.v3.messaging.models import MulticastRequest, TextMessage

multicast_request = MulticastRequest(
    to=["user1", "user2", "user3"],
    messages=[
        TextMessage(text="Important announcement to selected users")
    ]
)
messaging_api.multicast(multicast_request)

User Profile Retrieval

# Get user profile
profile = messaging_api.get_profile("USER_ID")
print(f"User: {profile.display_name}")
print(f"Language: {profile.language}")

# Get group information
group_info = messaging_api.get_group_summary("GROUP_ID")
print(f"Group: {group_info.group_name}")

Message Quota Monitoring

# Check current quota
quota = messaging_api.get_message_quota()
print(f"Quota type: {quota.type}")
print(f"Remaining: {quota.value}")

# Get usage statistics
stats = messaging_api.get_number_of_sent_push_messages("20240101")
print(f"Push messages sent: {stats.success}")

Install with Tessl CLI