CHRLINE-Patch

https://github.com/wedeach/chrline-patch
Admin
CHRLINE-Patch is a patched and updated version of the CHRLINE API library, primarily intended for...
Tokens:10,279
Snippets:56
Trust Score:7.2
License:BSD-3-Clause
Update:11 months ago
Show doc for...
Tokens:
Raw
### Implement Event-Driven Bots with CHRLINE Hooks System

Source: https://context7.com/wedeach/chrline-patch/llms.txt

Demonstrates the setup for creating event-driven bots using CHRLINE's `HooksTracer`. It shows how to initialize the CHRLINE client and the `HooksTracer` with custom command prefixes. The example includes defining event hooks for `onReady` and `onInitializePushConn` using the `@tracer.Event` decorator.

```python
from CHRLINE import CHRLINE
from CHRLINE.hooks import HooksTracer

cl = CHRLINE(useThrift=True, device="IOSIPAD")
tracer = HooksTracer(cl, prefixes=["!", ".", "/"])

# Event hooks
class EventHook:
    @tracer.Event
    def onReady():
        print('Bot is ready!')

    @tracer.Event
    def onInitializePushConn():
        print('Push connection initialized!')
```

--------------------------------

### LINE Request Example with X-LS Header

Source: https://github.com/wedeach/chrline-patch/blob/master/docs/X-LS.md

Demonstrates a typical LINE API request flow using the X-LS header for authentication. The example shows POST requests to various LINE endpoints and the corresponding server responses containing the X-LS token.

```text
->  POST ga2.line.naver.jp/P5
    Headers:
        X-Line-Application: ANDROID	11.2.1	Android OS	9.0.0
        X-Line-Access: mid:xxxxxxxxx..xxxxxxxxxx=

<-  OK ga2.line.naver.jp/P5
    Headers:
        x-lc: 200
        x-ls: xxxxxxxxxxxxxxx

<-  POST ga2.line.naver.jp/P5
    Headers:
        x-ls: xxxxxxxxxxxxxxx

<-  POST ga2.line.naver.jp/S4
    Headers:
        x-ls: xxxxxxxxxxxxxxx

<-  POST ga2.line.naver.jp/CH4
    Headers:
        x-ls: xxxxxxxxxxxxxxx
......
```

--------------------------------

### Implement Custom Data Persistence for Bots

Source: https://context7.com/wedeach/chrline-patch/llms.txt

This example demonstrates how to implement custom data persistence for bots using the cl.custom_data object. It shows initialization, adding/checking admin users, updating settings, and toggling features, with automatic saving to disk. The `bot_with_data` function illustrates how to use persistent data within a bot's operational loop.

```python
# Initialize custom data
cl.custom_data['admin'] = cl.custom_data.get('admin', [])
cl.custom_data['settings'] = {
    'auto_reply': True,
    'language': 'en'
}

# Add admin user
def add_admin(user_mid):
    if user_mid not in cl.custom_data['admin']:
        cl.custom_data['admin'].append(user_mid)
        cl.saveCustomData()
        return True
    return False

# Check if user is admin
def is_admin(user_mid):
    return user_mid in cl.custom_data.get('admin', [])

# Update settings
cl.custom_data['settings']['auto_reply'] = False
cl.saveCustomData()

# Toggle feature
cl.custom_data['auto_join'] = not cl.custom_data.get('auto_join', False)
cl.saveCustomData()

# Bot with persistent data
def bot_with_data(op, cl):
    if op[3] == 26:  # RECEIVE_MESSAGE
        msg = op[20]
        sender = msg[1]
        text = msg.get(10, "").lower()

        if text == "makeadmin" and sender == cl.mid:
            cl.custom_data['admin'].append(sender)
            cl.saveCustomData()
            cl.replyMessage(msg, "You are now admin!")

        elif text == "stats" and is_admin(sender):
            stats = f"Admins: {len(cl.custom_data['admin'])}\n"
            stats += f"Auto-join: {cl.custom_data.get('auto_join', False)}"
            cl.replyMessage(msg, stats)

cl.trace(bot_with_data)
```

--------------------------------

### Profile and Contact Management in Python

Source: https://context7.com/wedeach/chrline-patch/llms.txt

Provides functions to retrieve and manage user profiles and contacts. This includes getting your own profile, fetching contacts by MID, listing all friends, blocking/unblocking users, and retrieving blocked lists.

```python
# Get own profile
profile = cl.getProfile()
print(f"Display Name: {profile['displayName']}")
print(f"Status Message: {profile.get('statusMessage', 'None')}")
print(f"MID: {profile['mid']}")
print(f"Picture Status: {profile.get('pictureStatus')}")

# Get contact by MID
contact = cl.getContact("u1234567890abcdef")
print(f"Contact Name: {contact['displayName']}")

# Get multiple contacts
mids = ["u1234567890abcdef", "u0987654321fedcba"]
contacts = cl.getContacts(mids)
for contact in contacts:
    print(f"Name: {contact['displayName']}, Status: {contact.get('statusMessage')}")

# Get all friends
all_mids = cl.getAllContactIds()
print(f"Total friends: {len(all_mids)}")

# Get contact with V3 API
contacts_v3 = cl.getContactsV3(["u1234567890abcdef"])

# Find contacts by phone number
phone_contacts = cl.findContactsByPhone(["0912345678", "0923456789"])

# Block and unblock users
cl.blockContact("u1234567890abcdef")
cl.unblockContact("u1234567890abcdef")

# Get blocked list
blocked = cl.getBlockedContactIds()
print(f"Blocked users: {len(blocked)}")
```

--------------------------------

### Access Timeline and Social Features (BIZ Services)

Source: https://context7.com/wedeach/chrline-patch/llms.txt

This snippet shows how to access the BIZ manager to interact with LINE's Timeline and social features. It includes an example of fetching the home timeline posts and printing their content. Ensure the cl object is initialized and has access to BIZ services.

```python
# Access BIZ manager
biz = cl.biz

# Get timeline posts
timeline = biz.TL.getHomeTimeline(limit=20)
for post in timeline:
    print(f"Post: {post.get('text', 'No text')}")
```

--------------------------------

### Get and View Stories

Source: https://context7.com/wedeach/chrline-patch/llms.txt

Functions to retrieve available stories and view a specific story. It utilizes the `biz.ST` module for story-related operations. The `getStories` function returns a list of stories, which can be iterated to display author information.

```python
# Get stories
stories = biz.ST.getStories()
for story in stories:
    print(f"Story from: {story.get('author')}")

# View story
story_id = "s1234567890"
biz.ST.viewStory(story_id)
```

--------------------------------

### Run Long Polling with Push - CHRLINE Python

Source: https://github.com/wedeach/chrline-patch/blob/master/examples/README.md

Starts the HooksTracer long polling loop using Push endpoint with specified services. The initServices parameter specifies which PushType services to poll (remove 3 if OpenChat/Square is not supported).

```python
tracer.run(
  2,
  **{
      'initServices': [1, 3, 6, 8, 10]
  },
)
```

--------------------------------

### Manage LINE Groups and Chats

Source: https://context7.com/wedeach/chrline-patch/llms.txt

This snippet demonstrates how to perform common group and chat management tasks using the cl object. It covers retrieving group information, creating new groups, inviting users, accepting invitations, leaving groups, kicking members, updating group names, getting chat members, and canceling invitations. Ensure the cl object is properly initialized before use.

```python
# Get all joined groups
all_chats = cl.getAllChatMids()
group_mids = all_chats.get('memberChatMids', [])
print(f"Member of {len(group_mids)} groups")

# Get group information
group_info = cl.getChat(group_mids[0])
print(f"Group Name: {group_info.get('chatName')}")

# Create new group
new_group = cl.createChat("My New Group", ["u1234567890abcdef", "u0987654321fedcba"])
new_group_mid = new_group['chatMid']

# Invite users to group
cl.inviteIntoChat(new_group_mid, ["u_another_user_mid"])

# Accept chat invitation
cl.acceptChatInvitation("c_invitation_chat_mid")

# Leave group
cl.deleteOtherFromChat("c1234567890abcdef", [cl.mid])

# Kick member from group
cl.deleteOtherFromChat("c1234567890abcdef", ["u_member_to_kick"])

# Update group name
cl.updateChat("c1234567890abcdef", "New Group Name")

# Get chat members
members = cl.getChatMembers("c1234567890abcdef")
for member in members:
    print(f"Member: {member['displayName']}")

# Cancel chat invitation
cl.cancelChatInvitation("c1234567890abcdef", ["u1234567890abcdef"])
```

--------------------------------

### Send Various Message Types using CHRLINE

Source: https://context7.com/wedeach/chrline-patch/llms.txt

Provides examples for sending different types of messages including simple text, messages to groups, messages with custom metadata, stickers, images, location data, and contact cards. It highlights the use of `sendMessage` and `sendLocation`, `sendContact` methods with specific parameters for content type and metadata.

```python
# Send simple text message
cl.sendMessage(to="u1234567890abcdef", text="Hello from CHRLINE!")

# Send message to group chat
group_mid = "c1234567890abcdef"
cl.sendMessage(to=group_mid, text="Hello group!")

# Send message with custom metadata
cl.sendMessage(
    to="u1234567890abcdef",
    text="Check this out",
    contentMetadata={\"MENTION\": '{\"MENTIONEES\":[{\"S\":\"0\",\"E\":\"5\",\"M\":\"u9876543210fedcba\"}]}'}
)

# Send sticker
cl.sendMessage(
    to="u1234567890abcdef",
    text=None,
    contentType=7,  # Sticker type
    contentMetadata={"STKID": "52002734", "STKPKGID": "11537", "STKVER": "1"}
)

# Send image (requires upload first)
cl.sendMessage(
    to="u1234567890abcdef",
    text=None,
    contentType=1  # Image type
)

# Send location
cl.sendLocation(
    to="u1234567890abcdef",
    title="Meeting Point",
    la=25.0330,
    lb=121.5654,
    subTile="Taipei 101"
)

# Send contact card
cl.sendContact(
    to="u1234567890abcdef",
    mid="u9876543210fedcba",
    displayName="John Doe"
)
```

--------------------------------

### Get User Social Profile

Source: https://context7.com/wedeach/chrline-patch/llms.txt

Retrieves the social profile information for a given user, including follower and following counts. It uses the `biz.getProfile` method, requiring the user's member ID (`cl.mid`).

```python
# Get social profile
social_profile = biz.getProfile(cl.mid)
print(f"Following: {social_profile.get('followingCount')}")
print(f"Followers: {social_profile.get('followerCount')}")
```

--------------------------------

### Run Long Polling with Normal Mode - CHRLINE Python

Source: https://github.com/wedeach/chrline-patch/blob/master/examples/README.md

Starts the HooksTracer long polling loop using normal polling mode instead of Push. Use this when the device or account does not support the PUSH endpoint for long polling operations.

```python
tracer.run()  # for normal
```

--------------------------------

### LIFF Operations: Issue Token and Get Context

Source: https://context7.com/wedeach/chrline-patch/llms.txt

Handles LINE Front-end Framework (LIFF) interactions by issuing view tokens and retrieving context information. Requires chat MID and LIFF ID. Supports custom permissions by specifying language.

```python
# Issue LIFF view token
liff_token = cl.issueLiffView(
    chatMid="c1234567890abcdef",
    liffId="1234567890-abcdefgh"
)
print(f"LIFF Token: {liff_token}")

# Get LIFF context
context = cl.getLiffContext(liff_token)

# LIFF with custom permissions
liff_result = cl.issueLiffView(
    chatMid="u1234567890abcdef",
    liffId="1234567890-abcdefgh",
    lang="en_US"
)
```

--------------------------------

### Get Timeline Posts and Post Details

Source: https://context7.com/wedeach/chrline-patch/llms.txt

Retrieves details for a specific post using its ID and fetches a list of posts from a user's timeline. Requires a post ID for `getPost` and a member ID (`mid`) for `getUserTimeline`.

```python
# Get post details
post_details = biz.TL.getPost(post_id)

# Get user timeline posts
user_posts = biz.TL.getUserTimeline(
    mid="u1234567890abcdef",
    limit=10
)
```

--------------------------------

### Initialize CHRLINE Client with Various Authentication Methods

Source: https://context7.com/wedeach/chrline-patch/llms.txt

Demonstrates how to initialize the CHRLINE client using different authentication methods such as QR code, auth token, email/password, and phone number. It also shows advanced configuration options like device settings, protocol forcing, debugging, and custom save paths. The output includes logged-in user information, auth token, and user MID.

```python
from CHRLINE import CHRLINE

# QR Code login (default)
cl = CHRLINE(device="IOSIPAD", version="10.21.3")
# Displays QR code, waits for scan, then authenticates

# Login with existing auth token
cl = CHRLINE("your_auth_token_here", device="IOSIPAD")

# Email and password login
cl = CHRLINE("user@example.com", "password123", device="CHROMEOS", version="3")

# Phone number login (passwordless)
cl = CHRLINE(phone="0912345678", region="TW", device="IOSIPAD")

# No login mode for testing
cl = CHRLINE(noLogin=True, device="DESKTOPWIN")

# Advanced configuration
cl = CHRLINE(
    device="CHROMEOS",
    version="3",
    useThrift=True,  # Enable native Thrift support
    forceTMCP=True,  # Force TMoreCompact protocol
    debug=True,  # Enable debug logging
    rootLogLevel=0,  # Detailed logging
    savePath="./data"  # Custom save directory
)

print(f"Logged in as: {cl.profile['displayName']}")
print(f"Auth Token: {cl.authToken}")
print(f"User MID: {cl.mid}")
```

--------------------------------

### Login with AuthToken - CHRLINE Python

Source: https://github.com/wedeach/chrline-patch/blob/master/examples/README.md

Initializes CHRLINE client using authentication token with device type and version specifications. This method requires a valid AuthToken from LINE and allows you to specify the device type and app version for the login session.

```python
cl = CHRLINE(
  Token,
  device="ANDROID",  # device type name
  version="15.7.1",  # device app version
)
```

--------------------------------

### Login with SQR - CHRLINE Python

Source: https://github.com/wedeach/chrline-patch/blob/master/examples/README.md

Initializes CHRLINE client using SQR (Square/QR code) authentication. This is the simplest login method that uses QR code scanning for authentication without explicit credentials.

```python
cl = CHRLINE()
```

--------------------------------

### Generate TField Parameters for Fetch Operations (Python)

Source: https://github.com/wedeach/chrline-patch/blob/master/docs/DummyProtocol.md

Demonstrates how to create parameter lists for fetch operations using the Dummy Protocol. Each sublist represents a TField, with elements indicating type, ID, and data.

```python
params = [
    [10, 2, revision],
    [8, 3, count],
    [10, 4, self.globalRev],
    [10, 5, self.individualRev]
]
```

--------------------------------

### LINE Request with X-LS

Source: https://github.com/wedeach/chrline-patch/blob/master/docs/X-LS.md

Demonstrates how to obtain the X-LS token by sending a request with the X-Line-Access header and how subsequent requests utilize the obtained X-LS token.

```APIDOC
## Obtain X-LS Token

### Description
Initiate a session by sending a POST request to the LINE server with the `X-Line-Access` header. The server will respond with the `x-ls` token in the response headers, which is used for subsequent authenticated requests within the same connection.

### Method
POST

### Endpoint
`ga2.line.naver.jp/P5`

### Parameters
#### Request Headers
- **X-Line-Application** (string) - Required - Application details (e.g., `ANDROID\t11.2.1\tAndroid OS\t9.0.0`)
- **X-Line-Access** (string) - Required - User access token.

### Request Example
```http
->  POST ga2.line.naver.jp/P5
    Headers:
        X-Line-Application: ANDROID\t11.2.1\tAndroid OS\t9.0.0
        X-Line-Access: mid:xxxxxxxxx..xxxxxxxxxx=
```

### Response
#### Success Response (200 OK)
- **x-lc** (integer) - Optional - Status code, especially when `x-lpv` is 1.
- **x-ls** (string) - The LINE Session token.

#### Response Example
```http
<-  OK ga2.line.naver.jp/P5
    Headers:
        x-lc: 200
        x-ls: xxxxxxxxxxxxxxx
```

## Subsequent Requests using X-LS

### Description
Once you have obtained the `x-ls` token, include it in the headers of subsequent requests to the LINE server to bypass direct user authentication for that session.

### Method
POST

### Endpoint
`ga2.line.naver.jp/P5`, `ga2.line.naver.jp/S4`, `ga2.line.naver.jp/CH4`, etc.

### Parameters
#### Request Headers
- **x-ls** (string) - Required - The LINE Session token obtained previously.

### Request Example
```http
<-  POST ga2.line.naver.jp/P5
    Headers:
        x-ls: xxxxxxxxxxxxxxx

<-  POST ga2.line.naver.jp/S4
    Headers:
        x-ls: xxxxxxxxxxxxxxx

<-  POST ga2.line.naver.jp/CH4
    Headers:
        x-ls: xxxxxxxxxxxxxxx
```

## Handling Status Codes with x-lpv

### Description
When the `x-lpv` header is set to 1, the server will always respond with a 200 OK status code. In such cases, the actual HTTP status code will be provided in the `x-lc` header.

### Method
POST

### Endpoint
`gd2.line.naver.jp/xx/api/xx/xxx` (Example endpoint)

### Parameters
#### Request Headers
- **x-lpv** (integer) - Optional - If set to 1, forces a 200 OK response, with the actual status in `x-lc`.

### Request Example
```http
->  POST gd2.line.naver.jp/xx/api/xx/xxx
    Headers:
        x-lpv: 1
```

### Response
#### Success Response (200 OK)
- **x-lc** (integer) - The actual status code of the request (e.g., 404).

#### Response Example
```http
<-  OK gd2.line.naver.jp/xx/api/xx/xxx
    Headers:
        x-lc: 404
```
```

--------------------------------

### Command Hooks for Interactive Commands in Python

Source: https://context7.com/wedeach/chrline-patch/llms.txt

Implements interactive commands such as 'ping', 'help', and 'profile'. These commands can be triggered by users and respond with predefined messages or information.

```python
class CommandHook:
    @tracer.Command(ignoreCase=True)
    def ping(self, msg, cl):
        '''Ping command'''
        cl.replyMessage(msg, "Pong! 🏓")

    @tracer.Command(ignoreCase=True)
    def help(self, msg, cl):
        '''Show help message'''
        cl.replyMessage(msg, "Commands: !ping, !help, !profile, !groups")

    @tracer.Command(ignoreCase=True)
    def profile(self, msg, cl):
        '''Get user profile'''
        profile = cl.getProfile()
        info = f"Name: {profile['displayName']}\nMID: {profile['mid']}"
        cl.replyMessage(msg, info)
```

--------------------------------

### Login with Phone Number - CHRLINE Python

Source: https://github.com/wedeach/chrline-patch/blob/master/examples/README.md

Initializes CHRLINE client using a phone number and region code (ISO-3166 format). This method allows authentication through phone number verification instead of AuthToken, useful for alternative login flows.

```python
cl = CHRLINE(
  phone=PhoneNumber,  # phone number
  region="TW",        # phone number region with ISO-3166
)
```

--------------------------------

### Create, Like, Unlike, Comment on Timeline Posts

Source: https://context7.com/wedeach/chrline-patch/llms.txt

Demonstrates core timeline post management functions including creation, liking, unliking, and commenting. These operations interact with the `biz.TL` module for timeline-related actions.

```python
new_post = biz.TL.createPost(
    text="Hello from CHRLINE!",
    holdingTime=0  # Post immediately
)

# Like a post
post_id = "1234567890"
biz.TL.likePost(post_id)

# Unlike a post
biz.TL.unlikePost(post_id)

# Comment on post
biz.TL.createComment(
    postId=post_id,
    text="Great post!"
)
```

--------------------------------

### Reply to Messages using CHRLINE

Source: https://context7.com/wedeach/chrline-patch/llms.txt

Illustrates how to implement message replying functionality within a bot handler. It covers simple text replies, replies with different content types (like emojis), sticker replies, and replying to messages within Square/OpenChat environments. The code uses `cl.replyMessage` with message objects and optional content parameters.

```python
def bot_handler(op, cl):
    if op[3] == 26:  # RECEIVE_MESSAGE operation
        msg = op[20]
        sender = msg[1]
        text = msg.get(10, "")

        # Simple reply
        cl.replyMessage(msg, "Got your message!")

        # Reply with different content type
        cl.replyMessage(msg, "👍", contentType=0)

        # Reply with sticker
        cl.replyMessage(
            msg,
            None,
            contentType=7,
            contentMetadata={"STKID": "52002734", "STKPKGID": "11537"}
        )

        # Reply to Square/OpenChat message
        if msg.get(3) == 7:  # Thread message
            cl.replyMessage(
                msg,
                "Reply in Square!",
                squareChatMid=msg.get('squareChatMid')
            )

cl.trace(bot_handler)
```

--------------------------------

### Register HooksTracer for Long Polling - CHRLINE Python

Source: https://github.com/wedeach/chrline-patch/blob/master/examples/README.md

Sets up HooksTracer instance with CHRLINE client and command prefixes for event tracking and long polling. HooksTracer manages event registration, command parsing, and message routing with specified command prefixes.

```python
from CHRLINE.hooks import HooksTracer

tracer = HooksTracer(
    cl,             # CHRLINE client
    prefixes=["!"], # cmd prefixes
)
```

--------------------------------

### Register Text Command with Aliases - CHRLINE Python

Source: https://github.com/wedeach/chrline-patch/blob/master/examples/README.md

Registers a command handler with multiple aliases using the alt parameter. Multiple command triggers can invoke the same handler function with case-insensitive matching across specified message types.

```python
@tracer.Command(alt=["hello"], ignoreCase=True, toType=[0, 2, 4])
def hi(self, msg, cl):
    cl.replyMessage(msg, f"Hi!")
```

--------------------------------

### Register Before and After Event Decorators - CHRLINE Python

Source: https://github.com/wedeach/chrline-patch/blob/master/examples/README.md

Registers debugging handlers that execute before and after all operations for comprehensive event tracking. The Before decorator handles all operations while After decorator processes untracked operations.

```python
@tracer.Before(tracer.HooksType["Operation"])
def __before(self, op, cl):
    # handle all op
    pass

@tracer.After(tracer.HooksType["Operation"])
def __after(self, op, cl):
    # handle not tracked op
    pass
```

--------------------------------

### Register Text Command Handler - CHRLINE Python

Source: https://github.com/wedeach/chrline-patch/blob/master/examples/README.md

Registers a command handler that responds to specific text triggers with optional case-insensitivity and target types (MIDType). When a user types the command, the bot replies with the specified message.

```python
@tracer.Command(ignoreCase=True, toType=[0, 2, 4])
def hi(self, msg, cl):
    cl.replyMessage(msg, f"Hi!")
```

--------------------------------

### Send and Manage End-to-End Encrypted (E2EE) Messages

Source: https://context7.com/wedeach/chrline-patch/llms.txt

This section details how to send and manage end-to-end encrypted messages, including automatic encryption, sending encrypted images, renewing keys, and retrieving backup certificates. It handles potential E2EE errors by retrying with specific E2EE methods. Ensure the cl object is initialized and configured for E2EE.

```python
# Send E2EE message (automatic encryption)
try:
    cl.sendMessage(to="u1234567890abcdef", text="Secret message")
except Exception as e:
    if "E2EE" in str(e):
        # Automatically retry with E2EE
        cl.sendMessageWithE2EE(
            to="u1234567890abcdef",
            text="Secret message",
            contentType=0
        )

# Send E2EE image
cl.sendMessageWithE2EE(
    to="u1234567890abcdef",
    text=None,
    contentType=1,  # Image
    contentMetadata={}
)

# Renew E2EE keys
cl.sendMessageWithE2EE(
    to="u1234567890abcdef",
    text="Message with new key",
    renewKey=True
)

# Get E2EE key backup
backup_keys = cl.getE2EEKeyBackupCertificates()

# Negotiate E2EE key
key_info = cl.negotiateE2EEPublicKey("u1234567890abcdef")

# Check E2EE key status
try:
    msg_result = cl.sendMessage(to="u1234567890abcdef", text="Test", autoE2EE=True)
except Exception as e:
    print(f"E2EE required: {e}")
```

--------------------------------

### LINE API Response with Status Code in x-lc Header

Source: https://github.com/wedeach/chrline-patch/blob/master/docs/X-LS.md

Illustrates how LINE API responses indicate status codes within the 'x-lc' header when the 'x-lpv' header is set to 1. This allows for consistent 'OK (200)' responses while conveying actual status information.

```text
->  POST gd2.line.naver.jp/xx/api/xx/xxx
    Headers:
        x-lpv: 1

<-  OK gd2.line.naver.jp/xx/api/xx/xxx
    Headers:
        x-lc: 404
```

--------------------------------

### Content Type Hooks for Message Handling in Python

Source: https://context7.com/wedeach/chrline-patch/llms.txt

Handles different content types of messages, including text, images, and stickers. It allows for custom tracing and replying to messages based on their content type.

```python
class ContentHook:
    @tracer.Content(0)  # Text message
    def TextMessage(self, msg, cl):
        text = msg.text
        self.trace(msg, self.HooksType['Command'], cl)

    @tracer.Content(1)  # Image message
    def ImageMessage(self, msg, cl):
        cl.replyMessage(msg, "Nice image!")

    @tracer.Content(7)  # Sticker message
    def StickerMessage(self, msg, cl):
        stk_id = msg.contentMetadata.get('STKID')
        cl.replyMessage(msg, f"Sticker ID: {stk_id}")
```

--------------------------------

### Interact with LINE Square (OpenChat) Communities

Source: https://context7.com/wedeach/chrline-patch/llms.txt

This snippet covers various operations related to LINE Square (OpenChat), including retrieving joined squares, fetching square and chat information, sending messages to square chats, managing members, joining/leaving squares, checking authority, and searching for squares. It requires the cl object to be authenticated and potentially have Square permissions.

```python
# Get joined squares
squares = cl.getJoinedSquares()
for square in squares:
    print(f"Square: {square['squareName']}")

# Get square information
square_mid = "s1234567890abcdef"
square_info = cl.getSquare(square_mid)

# Get square chats
square_chats = cl.getSquareChats(square_mid)
for chat in square_chats:
    print(f"Chat: {chat.get('chatName')}")

# Send message to Square chat
square_chat_mid = "m1234567890abcdef"
cl.sendMessage(
    to=square_chat_mid,
    text="Hello Square!",
    contentType=0
)

# Get square members
members = cl.getSquareMembers(square_mid)

# Join square
cl.joinSquare(square_mid)

# Leave square
cl.leaveSquare(square_mid)

# Get square authority (admin check)
authority = cl.getSquareAuthority(square_mid)

# Get square chat members
chat_members = cl.getSquareChatMembers(square_chat_mid)

# Approve square join request (if admin)
cl.approveSquareMembers(square_mid, ["u1234567890abcdef"])

# Search squares
search_results = cl.searchSquares("Python Programming")
```

--------------------------------

### Group and Chat Operations in Python

Source: https://context7.com/wedeach/chrline-patch/llms.txt

Includes functionalities for managing group chats, handling invitations, and performing member operations within groups. This section is currently empty but intended for group management functionalities.

--------------------------------

### Manual Operation Polling with CHRLINE in Python

Source: https://context7.com/wedeach/chrline-patch/llms.txt

Demonstrates how to manually handle CHR LINE operations without using the hooks framework. This allows for custom logic in response to various operation types like sending/receiving messages and contact additions.

```python
from CHRLINE import CHRLINE

cl = CHRLINE("your_auth_token", device="IOSIPAD")

def custom_bot(op, cl):
    op_type = op.get(3)  # Operation type

    if op_type == 25:  # SEND_MESSAGE (own messages)
        msg = op[20]
        to = msg[2]
        if msg[15] == 0:  # Text message
            text = msg[10]
            print(f"You sent: {text}")

    elif op_type == 26:  # RECEIVE_MESSAGE
        msg = op[20]
        sender = msg[1]
        text = msg.get(10, "")

        if text.lower() == "ping":
            cl.sendMessage(msg[2], "Pong!")
        elif text.lower() == "time":
            import datetime
            cl.replyMessage(msg, f"Current time: {datetime.datetime.now()}")

    elif op_type == 55:  # NOTIFIED_ADD_CONTACT
        mid = op.get(10)
        print(f"New contact added: {mid}")

    elif op_type == 124:  # NOTIFIED_INVITE_INTO_CHAT
        chat_mid = op[10]
        inviter = op[12][0] if op.get(12) else None
        # Auto-join if invited by specific user
        if inviter == "u_trusted_user_mid":
            cl.acceptChatInvitation(chat_mid)

    elif op_type == 19:  # NOTIFIED_UPDATE_PROFILE
        print("Profile updated")

# Run with threading enabled (default)
cl.trace(custom_bot, isThreading=True)

# Run without threading for sequential processing
# cl.trace(custom_bot, isThreading=False)
```

--------------------------------

### Operation Hooks for Low-Level Operations in Python

Source: https://context7.com/wedeach/chrline-patch/llms.txt

Defines classes for handling various CHR LINE operations like receiving messages and inviting users to chats. It utilizes a tracer decorator for operation types.

```python
class OpHook:
    @tracer.Operation(26)  # RECEIVE_MESSAGE
    def recvMessage(self, op, cl):
        msg = op.message
        self.trace(msg, self.HooksType["Content"], cl)

    @tracer.Operation(124)  # NOTIFIED_INVITE_INTO_CHAT
    def inviteIntoChat(self, op, cl):
        chat_mid = cl.checkAndGetValue(op, 'param1', 10)
        cl.acceptChatInvitation(chat_mid)
```

--------------------------------

### Safe Message Sending with Error Handling

Source: https://context7.com/wedeach/chrline-patch/llms.txt

Implements a robust message sending function that handles specific LINE service exceptions like E2EE requirements, invalid mids, and account bans. It provides custom logging for different error codes and allows for retries with exponential backoff.

```python
from CHRLINE.exceptions import LineServiceException

def safe_send_message(cl, to, text):
    try:
        result = cl.sendMessage(to=to, text=text)
        return result
    except LineServiceException as e:
        if e.code == 82:
            print("E2EE required, switching to E2EE")
            return cl.sendMessageWithE2EE(to=to, text=text)
        elif e.code == 99:
            print("Invalid mid or chat")
            return None
        elif e.code == 100:
            print("Account banned")
            raise
        else:
            print(f"Service error {e.code}: {e.message}")
            return None
    except Exception as e:
        print(f"Unexpected error: {e}")
        return None

# Retry with exponential backoff
import time

def send_with_retry(cl, to, text, max_retries=3):
    for attempt in range(max_retries):
        try:
            return cl.sendMessage(to=to, text=text)
        except LineServiceException as e:
            if e.code == 100:  # Ban - don't retry
                raise
            wait_time = 2 ** attempt
            print(f"Retry {attempt + 1}/{max_retries} after {wait_time}s")
            time.sleep(wait_time)
    raise Exception("Max retries exceeded")

# Use in bot
def error_handling_bot(op, cl):
    if op[3] == 26:
        msg = op[20]
        try:
            safe_send_message(cl, msg[2], "Response")
        except Exception as e:
            cl.log(f"Failed to send: {e}")
```

--------------------------------

### Register Message Content Handler - CHRLINE Python

Source: https://github.com/wedeach/chrline-patch/blob/master/examples/README.md

Registers a handler for specific message content types using Content decorator (ContentType 0 = TEXT). Processes incoming text messages and routes them to command handlers for further processing.

```python
@tracer.Content(0)
def TextMessage(self, msg, cl):
  self.trace(msg, self.HooksType["Command"], cl)
```

--------------------------------

### Square Event Hooks for Notifications in Python

Source: https://context7.com/wedeach/chrline-patch/llms.txt

Handles square event notifications, specifically for notification messages. It extracts and traces message content from the event payload.

```python
class SquareEventHook:
    @tracer.SquareEvent(29)  # NOTIFICATION_MESSAGE
    def NOTIFICATION_MESSAGE(self, event, cl):
        payload = cl.checkAndGetValue(event, 'payload', 4)
        notificationMessage = cl.checkAndGetValue(payload, 'notificationMessage', 30)
        squareMessage = cl.checkAndGetValue(notificationMessage, 'squareMessage', 2)
        message = cl.checkAndGetValue(squareMessage, 'message', 1)
        self.trace(message, self.HooksType["Content"], cl)
```

--------------------------------

### Register Long Polling Event Handler - CHRLINE Python

Source: https://github.com/wedeach/chrline-patch/blob/master/examples/README.md

Registers an event handler for specific operation types using the Operation decorator (OpType 26 = RECEIVE_MESSAGE). When messages are received from others, the decorated function processes the message content and triggers appropriate handlers.

```python
@tracer.Operation(26)
def recvMessage(self, op, cl):
    msg = op[20]

    self.trace(msg, self.HooksType["Content"], cl)
```
Tokens:
Raw