python-mattermost-driver

The primary entry point for the python-mattermost-driver is the Driver class. Most interactions with the Mattermost API are performed through an instance of this class. To access information about the currently authenticated user (such as the userid), use the client attribute on your Driver instance.

# Example of accessing the logged in user's ID
# Assuming 'mm' is an instance of Driver
user_id = mm.client.userid

Install the driver using pip to interact with the Mattermost APIv4.

pip install mattermostdriver

You can authenticate with Mattermost by using a .netrc file. This method allows the underlying requests library to handle credentials automatically, providing a clean way to manage authentication without hardcoding tokens or usernames in your scripts.

# Example of authentication with .netrc
# (Refer to mmDriverTokenAuthExample.py for the full implementation)

You can listen to real-time events by initializing a websocket connection. This must be done after calling login(), as the websocket requires an authentication token.

Synchronous (Driver)

Use init_websocket(event_handler). This method runs the event loop and will not return until the websocket is disconnected.

Asynchronous (AsyncDriver)

Use await init_websocket(event_handler). This returns a coroutine that can be awaited; it will not return until shutdown is called.

Example Event Handler

async def my_event_handler(message):
    print(message)

async def my_event_handler(message):
    print(message)

# For AsyncDriver
await driver.init_websocket(my_event_handler)

# For Driver
driver.init_websocket(my_event_handler)
# Note: the sync version runs the loop internally

The Driver class is the primary entrypoint for synchronous interaction with the Mattermost API. It supports context manager usage (with statement) to ensure the client is properly managed.

To use it, initialize the driver with your configuration, call login() to authenticate, and then access API endpoints via properties like driver.users, driver.posts, or driver.channels.

from mattermostdriver import Driver

options = {
    "url": "localhost",
    "login_id": "mmuser",
    "password": "mmuser"
}

with Driver(options=options) as driver:
    driver.login()
    user = driver.users.get_user("me")
    print(user)
    driver.logout()

The AsyncDriver class is designed for asynchronous applications using asyncio. It supports asynchronous context management (async with).

All authentication methods (login, logout) and websocket initializations are coroutines and must be awaited.

import asyncio
from mattermostdriver import AsyncDriver

async def main():
    options = {
        "url": "localhost",
        "token": "your_token"
    }
    
    async with AsyncDriver(options=options) as driver:
        await driver.login()
        user = await driver.users.get_user("me")
        print(user)
        await driver.logout()

asyncio.run(main())

To upload a file, use foo.files.upload_file with a files dictionary. To attach the uploaded file to a post, capture the file ID and pass it in the file_ids list within the options dictionary of create_post.

# 1. Get channel ID
channel_id = foo.channels.get_channel_by_name_and_team_name('team', 'channel')['id']

# 2. Upload file
file_id = foo.files.upload_file(
    channel_id=channel_id,
    files={'files': ('filename.txt', open('filename.txt', 'rb'))}
)['file_infos'][0]['id']

# 3. Create post with attachment
foo.posts.create_post(options={
    'channel_id': channel_id,
    'message': 'This is the important file',
    'file_ids': [file_id]
})