tessl/pypi-office365-rest-python-client
Microsoft 365 & Microsoft Graph Library for Python
—
Pending
Quality
Pending
Does it follow best practices?
Impact
Pending
No eval scenarios have been run
teams.mddocs/
Teams Integration
Complete Microsoft Teams functionality including teams, channels, chats, messages, and collaborative features through Microsoft Graph API. Provides comprehensive communication and collaboration capabilities for Microsoft Teams environments.
Capabilities
Team Management
Complete team lifecycle management including creation, configuration, membership, and settings with support for team templates and governance policies.
class Team:
"""Microsoft Teams team with comprehensive management capabilities."""
# Core Properties
id: str
display_name: str
description: str
internal_id: str
classification: str
specialization: str
visibility: str # "private" or "public"
web_url: str
is_archived: bool
def get(self) -> 'Team':
"""
Retrieve team information and settings.
Returns:
Team: Updated team object
"""
def update(self) -> 'Team':
"""
Update team properties and settings.
Returns:
Team: Updated team object
"""
def delete(self) -> None:
"""Delete team and associated resources."""
def archive(self, should_set_spa_as_default_tab: bool = False) -> None:
"""
Archive team to read-only state.
Args:
should_set_spa_as_default_tab (bool): Set SharePoint as default tab
"""
def unarchive(self) -> None:
"""Restore archived team to active state."""
def clone(self, display_name: str, description: str = None, mail_nickname: str = None, classification: str = None, visibility: str = None, parts_to_clone: List[str] = None) -> 'Team':
"""
Clone team with specified configuration.
Args:
display_name (str): New team display name
description (str, optional): New team description
mail_nickname (str, optional): New team mail nickname
classification (str, optional): Team classification
visibility (str, optional): Team visibility ("private" or "public")
parts_to_clone (List[str], optional): Parts to clone ("apps", "tabs", "settings", "channels", "members")
Returns:
Team: Cloned team object
"""
# Navigation Properties
@property
def channels(self) -> 'ChannelCollection':
"""Team channels."""
@property
def members(self) -> 'ConversationMemberCollection':
"""Team members."""
@property
def owners(self) -> 'UserCollection':
"""Team owners."""
@property
def installed_apps(self) -> 'TeamsAppInstallationCollection':
"""Apps installed in the team."""
@property
def operations(self) -> 'TeamsAsyncOperationCollection':
"""Async operations for the team."""
class TeamCollection:
"""Collection of Microsoft Teams with query and management capabilities."""
def get(self) -> 'TeamCollection':
"""Retrieve collection of teams."""
def filter(self, expression: str) -> 'TeamCollection':
"""
Filter teams by OData expression.
Args:
expression (str): OData filter expression
Returns:
TeamCollection: Filtered collection
"""
def get_by_id(self, team_id: str) -> Team:
"""
Get team by ID.
Args:
team_id (str): Team unique identifier
Returns:
Team: Team object
"""
def create(self, team_creation_info: Dict[str, Any]) -> Team:
"""
Create new team.
Args:
team_creation_info (Dict): Team properties and configuration
Returns:
Team: Created team object
"""Channel Management
Team channel operations including standard channels, private channels, and shared channels with comprehensive message and file management.
class Channel:
"""Teams channel with messaging and file management capabilities."""
# Core Properties
id: str
display_name: str
description: str
email: str
web_url: str
membership_type: str # "standard", "private", "shared"
created_date_time: str
def get(self) -> 'Channel':
"""
Retrieve channel information.
Returns:
Channel: Updated channel object
"""
def update(self) -> 'Channel':
"""
Update channel properties.
Returns:
Channel: Updated channel object
"""
def delete(self) -> None:
"""Delete channel."""
def provision_email(self) -> str:
"""
Provision email address for channel.
Returns:
str: Channel email address
"""
def remove_email(self) -> None:
"""Remove email address from channel."""
# Navigation Properties
@property
def messages(self) -> 'ChatMessageCollection':
"""Channel messages."""
@property
def members(self) -> 'ConversationMemberCollection':
"""Channel members (for private channels)."""
@property
def tabs(self) -> 'TeamsTabCollection':
"""Channel tabs."""
@property
def files_folder(self) -> 'DriveItem':
"""Channel files folder."""
class ChannelCollection:
"""Collection of team channels with management capabilities."""
def get(self) -> 'ChannelCollection':
"""Retrieve collection of channels."""
def get_by_id(self, channel_id: str) -> Channel:
"""
Get channel by ID.
Args:
channel_id (str): Channel unique identifier
Returns:
Channel: Channel object
"""
def add(self, channel_creation_info: Dict[str, Any]) -> Channel:
"""
Create new channel.
Args:
channel_creation_info (Dict): Channel properties
Returns:
Channel: Created channel object
"""Chat and Messaging
One-on-one and group chat functionality with comprehensive message management, file attachments, and conversation history.
class Chat:
"""Teams chat conversation with messaging capabilities."""
# Core Properties
id: str
topic: str
created_date_time: str
last_updated_date_time: str
chat_type: str # "oneOnOne", "group", "meeting"
web_url: str
tenant_id: str
def get(self) -> 'Chat':
"""
Retrieve chat information.
Returns:
Chat: Updated chat object
"""
def update(self) -> 'Chat':
"""
Update chat properties.
Returns:
Chat: Updated chat object
"""
def send_activity_notification(self, topic: Dict[str, str], activity_type: str, chain_id: int = None, preview_text: str = None, template_parameters: List[Dict[str, str]] = None) -> None:
"""
Send activity notification to chat members.
Args:
topic (Dict): Notification topic information
activity_type (str): Type of activity
chain_id (int, optional): Notification chain ID
preview_text (str, optional): Preview text
template_parameters (List[Dict], optional): Template parameters
"""
# Navigation Properties
@property
def messages(self) -> 'ChatMessageCollection':
"""Chat messages."""
@property
def members(self) -> 'ConversationMemberCollection':
"""Chat members."""
@property
def tabs(self) -> 'TeamsTabCollection':
"""Chat tabs."""
@property
def installed_apps(self) -> 'TeamsAppInstallationCollection':
"""Apps installed in the chat."""
class ChatCollection:
"""Collection of chats with query capabilities."""
def get(self) -> 'ChatCollection':
"""Retrieve collection of chats."""
def filter(self, expression: str) -> 'ChatCollection':
"""
Filter chats by expression.
Args:
expression (str): OData filter expression
Returns:
ChatCollection: Filtered collection
"""
def get_by_id(self, chat_id: str) -> Chat:
"""
Get chat by ID.
Args:
chat_id (str): Chat unique identifier
Returns:
Chat: Chat object
"""
class ChatMessage:
"""Teams chat message with content and attachment support."""
# Core Properties
id: str
reply_to_id: str
e_tag: str
message_type: str # "message", "chatEvent", "typing"
created_date_time: str
last_modified_date_time: str
deleted_date_time: str
subject: str
summary: str
importance: str # "normal", "high", "urgent"
locale: str
web_url: str
def get(self) -> 'ChatMessage':
"""
Retrieve message information.
Returns:
ChatMessage: Updated message object
"""
def update(self) -> 'ChatMessage':
"""
Update message content.
Returns:
ChatMessage: Updated message object
"""
def delete(self) -> None:
"""Soft delete message."""
def undosoft_delete(self) -> None:
"""Undo soft delete of message."""
def set_reaction(self, reaction_type: str) -> None:
"""
Add reaction to message.
Args:
reaction_type (str): Reaction type ("like", "angry", "sad", "laugh", "heart", "surprised")
"""
def unset_reaction(self, reaction_type: str) -> None:
"""
Remove reaction from message.
Args:
reaction_type (str): Reaction type to remove
"""
# Navigation Properties
@property
def body(self) -> Dict[str, str]:
"""Message body content and format."""
@property
def from_(self) -> Dict[str, Any]:
"""Message sender information."""
@property
def attachments(self) -> List[Dict[str, Any]]:
"""Message attachments."""
@property
def mentions(self) -> List[Dict[str, Any]]:
"""User mentions in message."""
@property
def reactions(self) -> List[Dict[str, Any]]:
"""Message reactions."""
@property
def replies(self) -> 'ChatMessageCollection':
"""Message replies."""
@property
def hosted_contents(self) -> 'ChatMessageHostedContentCollection':
"""Hosted content in message."""
class ChatMessageCollection:
"""Collection of chat messages with query and posting capabilities."""
def get(self) -> 'ChatMessageCollection':
"""Retrieve collection of messages."""
def filter(self, expression: str) -> 'ChatMessageCollection':
"""
Filter messages by expression.
Args:
expression (str): OData filter expression
Returns:
ChatMessageCollection: Filtered collection
"""
def top(self, count: int) -> 'ChatMessageCollection':
"""
Limit results to top N messages.
Args:
count (int): Maximum number of messages
Returns:
ChatMessageCollection: Limited collection
"""
def add(self, message_info: Dict[str, Any]) -> ChatMessage:
"""
Send new message.
Args:
message_info (Dict): Message content and properties
Returns:
ChatMessage: Sent message object
"""
def get_by_id(self, message_id: str) -> ChatMessage:
"""
Get message by ID.
Args:
message_id (str): Message unique identifier
Returns:
ChatMessage: Message object
"""Team Membership Management
Comprehensive member and owner management with role assignments, permissions, and guest access control.
class ConversationMember:
"""Team or chat member with role and permission information."""
# Core Properties
id: str
display_name: str
roles: List[str] # "owner", "member", "guest"
visible_history_start_date_time: str
def get(self) -> 'ConversationMember':
"""
Retrieve member information.
Returns:
ConversationMember: Updated member object
"""
def update(self) -> 'ConversationMember':
"""
Update member properties and roles.
Returns:
ConversationMember: Updated member object
"""
def delete(self) -> None:
"""Remove member from team or chat."""
class ConversationMemberCollection:
"""Collection of conversation members with management capabilities."""
def get(self) -> 'ConversationMemberCollection':
"""Retrieve collection of members."""
def add(self, member_info: Dict[str, Any]) -> ConversationMember:
"""
Add new member to conversation.
Args:
member_info (Dict): Member information and roles
Returns:
ConversationMember: Added member object
"""
def get_by_id(self, member_id: str) -> ConversationMember:
"""
Get member by ID.
Args:
member_id (str): Member unique identifier
Returns:
ConversationMember: Member object
"""Usage Examples
Team Operations
from office365.graph_client import GraphClient
client = GraphClient.with_client_secret(client_id, client_secret, tenant)
# Get all teams
teams = client.teams.get().execute_query()
for team in teams:
print(f"Team: {team.display_name} ({team.visibility})")
# Get specific team
team = client.teams.get_by_id("team-id").get().execute_query()
print(f"Team: {team.display_name}, Members: {len(team.members)}")
# Create new team
new_team_info = {
"displayName": "Marketing Team",
"description": "Marketing team collaboration space",
"visibility": "private"
}
new_team = client.teams.create(new_team_info).execute_query()Channel and Messaging
# Get team channels
channels = team.channels.get().execute_query()
for channel in channels:
print(f"Channel: {channel.display_name} ({channel.membership_type})")
# Create new channel
channel_info = {
"displayName": "Project Alpha",
"description": "Discussion for Project Alpha",
"membershipType": "standard"
}
new_channel = team.channels.add(channel_info).execute_query()
# Send message to channel
message_info = {
"body": {
"contentType": "html",
"content": "<h1>Welcome to the team!</h1><p>Let's get started on our project.</p>"
}
}
sent_message = new_channel.messages.add(message_info).execute_query()
# Get channel messages
messages = new_channel.messages.top(20).get().execute_query()
for message in messages:
print(f"From: {message.from_['user']['displayName']}, Content: {message.body['content'][:50]}...")Chat Operations
# Get user's chats
chats = client.me.chats.get().execute_query()
for chat in chats:
print(f"Chat: {chat.topic or 'No topic'} ({chat.chat_type})")
# Get chat messages
chat = chats[0]
chat_messages = chat.messages.top(10).get().execute_query()
for message in chat_messages:
if message.message_type == "message":
print(f"Message: {message.body['content'][:100]}...")
# Send message to chat
chat_message_info = {
"body": {
"contentType": "text",
"content": "Hello everyone! How's the project going?"
}
}
new_message = chat.messages.add(chat_message_info).execute_query()Team Member Management
# Get team members
members = team.members.get().execute_query()
for member in members:
print(f"Member: {member.display_name}, Roles: {', '.join(member.roles)}")
# Add new member
member_info = {
"@odata.type": "#microsoft.graph.aadUserConversationMember",
"user@odata.bind": f"https://graph.microsoft.com/v1.0/users/{user_id}",
"roles": ["member"]
}
new_member = team.members.add(member_info).execute_query()
# Promote member to owner
member.roles = ["owner"]
member.update().execute_query()Types
from typing import Dict, List, Any, Optional
class TeamSettings:
"""Team configuration settings."""
allow_create_update_channels: bool
allow_create_private_channels: bool
allow_create_update_remove_tabs: bool
allow_create_update_remove_connectors: bool
allow_delete_channels: bool
allow_add_remove_apps: bool
allow_guests: bool
allow_team_mentions: bool
allow_channel_mentions: bool
class GuestSettings:
"""Team guest access settings."""
allow_create_update_channels: bool
allow_delete_channels: bool
class MemberSettings:
"""Team member permission settings."""
allow_create_update_channels: bool
allow_create_private_channels: bool
allow_create_update_remove_tabs: bool
allow_create_update_remove_connectors: bool
allow_delete_channels: bool
allow_add_remove_apps: bool
class MessagingSettings:
"""Team messaging configuration."""
allow_user_edit_messages: bool
allow_user_delete_messages: bool
allow_owner_delete_messages: bool
allow_team_mentions: bool
allow_channel_mentions: bool
class FunSettings:
"""Team fun and entertainment settings."""
allow_giphy: bool
giphy_content_rating: str # "strict", "moderate"
allow_stickers_and_memes: bool
allow_custom_memes: bool
class ChatMessageBody:
"""Chat message body content."""
content_type: str # "text", "html"
content: str
class ChatMessageFromIdentitySet:
"""Message sender identity information."""
application: Dict[str, str]
device: Dict[str, str]
user: Dict[str, str]
class ChatMessageAttachment:
"""Chat message attachment."""
id: str
content_type: str
content_url: str
content: str
name: str
thumbnail_url: str
class ChatMessageMention:
"""User mention in chat message."""
id: int
mention_text: str
mentioned: Dict[str, Any]
class ChatMessageReaction:
"""Reaction to chat message."""
reaction_type: str
created_date_time: str
user: Dict[str, str]Install with Tessl CLI
npx tessl i tessl/pypi-office365-rest-python-client