Office365-REST-Python-Client 3.0.0__py3-none-any.whl → 3.1.0__py3-none-any.whl

office365/teams/apps/removed_event_message_detail.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from office365.directory.permissions.identity_set import IdentitySet
+from office365.runtime.client_value import ClientValue
+
+
+@dataclass
+class TeamsAppRemovedEventMessageDetail(ClientValue):
+    initiator: IdentitySet = field(default_factory=IdentitySet)
+    teamsAppDisplayName: str | None = None
+    teamsAppId: str | None = None
+
+    @property
+    def entity_type_name(self) -> str:
+        return "microsoft.graph.TeamsAppRemovedEventMessageDetail"

office365/teams/apps/upgraded_event_message_detail.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from office365.directory.permissions.identity_set import IdentitySet
+from office365.runtime.client_value import ClientValue
+
+
+@dataclass
+class TeamsAppUpgradedEventMessageDetail(ClientValue):
+    initiator: IdentitySet = field(default_factory=IdentitySet)
+    teamsAppDisplayName: str | None = None
+    teamsAppId: str | None = None
+
+    @property
+    def entity_type_name(self) -> str:
+        return "microsoft.graph.TeamsAppUpgradedEventMessageDetail"

office365/teams/archived_event_message_detail.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from office365.directory.permissions.identity_set import IdentitySet
+from office365.runtime.client_value import ClientValue
+
+
+@dataclass
+class TeamArchivedEventMessageDetail(ClientValue):
+    initiator: IdentitySet = field(default_factory=IdentitySet)
+    teamId: str | None = None
+
+    @property
+    def entity_type_name(self) -> str:
+        return "microsoft.graph.TeamArchivedEventMessageDetail"

office365/teams/channels/channel.py

@@ -1,5 +1,6 @@
+from __future__ import annotations
+
 from datetime import datetime
-from typing import Optional
 from urllib.parse import quote
 
 from office365.entity import Entity
@@ -13,7 +14,7 @@ from office365.runtime.types.odata_property import odata
 from office365.teams.channels.membership_type import ChannelMembershipType
 from office365.teams.channels.provision_email_result import ProvisionChannelEmailResult
 from office365.teams.channels.shared_team_info import SharedWithChannelTeamInfo
-from office365.teams.chats.messages.message import ChatMessage
+from office365.teams.chats.messages.collection import ChatMessageCollection
 from office365.teams.members.conversation import ConversationMember
 from office365.teams.tabs.tab import TeamsTab
 
@@ -26,9 +27,9 @@ class Channel(Entity):
 
     def does_user_have_access(
         self,
-        user_id: Optional[str] = None,
-        tenant_id: Optional[str] = None,
-        user_principal_name: Optional[str] = None,
+        user_id: str | None = None,
+        tenant_id: str | None = None,
+        user_principal_name: str | None = None,
     ) -> ClientResult[bool]:
         """Determine whether a user has access to a shared channel.
 
@@ -78,44 +79,44 @@ class Channel(Entity):
 
     @odata(name="createdDateTime")
     @property
-    def created_datetime(self) -> Optional[datetime]:
+    def created_datetime(self) -> datetime | None:
         """
         Read only. Timestamp at which the channel was created.
         """
         return self.properties.get("createdDateTime", datetime.min)
 
     @property
-    def description(self) -> Optional[str]:
+    def description(self) -> str | None:
         """Optional textual description for the channel."""
-        return self.properties.get("Description", None)
+        return self.properties.get("Description")
 
     @property
-    def display_name(self) -> Optional[str]:
+    def display_name(self) -> str | None:
         """Channel name as it will appear to the user in Microsoft Teams. The maximum length is 50 characters"""
-        return self.properties.get("displayName", None)
+        return self.properties.get("displayName")
 
     @property
-    def email(self) -> Optional[str]:
+    def email(self) -> str | None:
         """The email address for sending messages to the channel. Read-only."""
-        return self.properties.get("email", None)
+        return self.properties.get("email")
 
     @property
-    def is_archived(self) -> Optional[bool]:
+    def is_archived(self) -> bool | None:
         """Indicates whether the channel is archived. Read-only."""
-        return self.properties.get("isArchived", None)
+        return self.properties.get("isArchived")
 
     @property
-    def is_favorite_by_default(self) -> Optional[bool]:
+    def is_favorite_by_default(self) -> bool | None:
         """Indicates whether the channel should be marked as recommended for all members of the team to show in
         their channel list. Note: All recommended channels automatically show in the channels list for
         education and frontline worker users. The property can only be set programmatically via the Create team method.
         The default value is false"""
-        return self.properties.get("isFavoriteByDefault", None)
+        return self.properties.get("isFavoriteByDefault")
 
     @property
-    def tenant_id(self) -> Optional[str]:
+    def tenant_id(self) -> str | None:
         """The ID of the Microsoft Entra tenant."""
-        return self.properties.get("tenantId", None)
+        return self.properties.get("tenantId")
 
     @odata(name="membershipType")
     @property
@@ -129,11 +130,11 @@ class Channel(Entity):
         return self.properties.get("membershipType", ChannelMembershipType.invalid)
 
     @property
-    def web_url(self) -> Optional[str]:
+    def web_url(self) -> str | None:
         """A hyperlink that will navigate to the channel in Microsoft Teams. This is the URL that you get when you
         right-click a channel in Microsoft Teams and select Get link to channel. This URL should be treated as an
         opaque blob, and not parsed. Read-only."""
-        return self.properties.get("webUrl", None)
+        return self.properties.get("webUrl")
 
     @odata(name="filesFolder")
     @property
@@ -153,11 +154,11 @@ class Channel(Entity):
         )
 
     @property
-    def messages(self) -> EntityCollection[ChatMessage]:
+    def messages(self) -> ChatMessageCollection:
         """A collection of all the messages in the channel."""
         return self.properties.get(
             "messages",
-            EntityCollection(self.context, ChatMessage, ResourcePath("messages", self.resource_path)),
+            ChatMessageCollection(self.context, ResourcePath("messages", self.resource_path)),
         )
 
     @property

office365/teams/channels/collection.py

@@ -1,9 +1,11 @@
-from typing import Any, Optional
+from __future__ import annotations
+
+from typing import Any
 
 from office365.entity_collection import EntityCollection
 from office365.runtime.queries.function import FunctionQuery
 from office365.teams.channels.channel import Channel
-from office365.teams.chats.messages.message import ChatMessage
+from office365.teams.chats.messages.collection import ChatMessageCollection
 
 
 class ChannelCollection(EntityCollection[Channel]):
@@ -13,7 +15,7 @@ class ChannelCollection(EntityCollection[Channel]):
         super().__init__(context, Channel, resource_path)
 
     def add(
-        self, display_name: str, description: Optional[str] = None, membership_type: Optional[str] = None, **kwargs: Any
+        self, display_name: str, description: str | None = None, membership_type: str | None = None, **kwargs: Any
     ) -> Channel:
         """Create a new channel in a Microsoft Team, as specified in the request body.
 
@@ -24,11 +26,14 @@ class ChannelCollection(EntityCollection[Channel]):
         """
         return super().add(displayName=display_name, description=description, membershipType=membership_type, **kwargs)
 
-    def get_all_messages(self) -> EntityCollection[ChatMessage]:
+    def get_all_messages(self) -> ChatMessageCollection:
         """
         Retrieve messages across all channels in a team, including text, audio, and video conversations.
+
+        Chain ``.filter(...)``/``.select(...)``/``.top(...)`` on the returned
+        collection to shape the request.
         """
-        return_type = EntityCollection(self.context, ChatMessage, self.resource_path)
+        return_type = ChatMessageCollection(self.context, self.resource_path)
         qry = FunctionQuery(self, "getAllMessages", None, return_type)
         self.context.add_query(qry)
         return return_type

office365/teams/chats/chat.py

@@ -1,13 +1,15 @@
+from __future__ import annotations
+
 from datetime import datetime
-from typing import Optional
 
+from office365.directory.permissions.grants.resource_specific import ResourceSpecificPermissionGrant
 from office365.entity import Entity
 from office365.entity_collection import EntityCollection
 from office365.runtime.paths.resource_path import ResourcePath
 from office365.runtime.types.odata_property import odata
 from office365.teams.apps.installation import TeamsAppInstallation
+from office365.teams.chats.messages.collection import ChatMessageCollection
 from office365.teams.chats.messages.info import ChatMessageInfo
-from office365.teams.chats.messages.message import ChatMessage
 from office365.teams.chats.viewpoint import ChatViewpoint
 from office365.teams.members.conversation_collection import ConversationMemberCollection
 from office365.teams.operations.async_operation import TeamsAsyncOperation
@@ -19,7 +21,7 @@ class Chat(Entity):
     """A chat is a collection of chatMessages between one or more participants. Participants can be users or apps."""
 
     @property
-    def chat_type(self) -> Optional[str]:
+    def chat_type(self) -> str | None:
         """Specifies the type of chat. Possible values are: group, oneOnOne, meeting, unknownFutureValue."""
         return self.properties.get("chatType", None)
 
@@ -30,13 +32,13 @@ class Chat(Entity):
         return self.properties.get("createdDateTime", datetime.min)
 
     @property
-    def is_hidden_for_all_members(self) -> Optional[bool]:
+    def is_hidden_for_all_members(self) -> bool | None:
         """Indicates whether the chat is hidden for all its members."""
         return self.properties.get("isHiddenForAllMembers", None)
 
     @odata(name="lastUpdatedDateTime")
     @property
-    def last_updated_datetime(self) -> Optional[datetime]:
+    def last_updated_datetime(self) -> datetime | None:
         """Date and time at which the chat was renamed or the list of members was last changed."""
         return self.properties.get("lastUpdatedDateTime", datetime.min)
 
@@ -48,12 +50,12 @@ class Chat(Entity):
         return self.properties.get("onlineMeetingInfo", TeamworkOnlineMeetingInfo())
 
     @property
-    def tenant_id(self) -> Optional[str]:
+    def tenant_id(self) -> str | None:
         """The identifier of the tenant in which the chat was created. Read-only."""
         return self.properties.get("tenantId", None)
 
     @property
-    def topic(self) -> Optional[str]:
+    def topic(self) -> str | None:
         """(Optional) Subject or topic for the chat. Only available for group chats."""
         return self.properties.get("topic", None)
 
@@ -65,7 +67,7 @@ class Chat(Entity):
         return self.properties.get("viewpoint", ChatViewpoint())
 
     @property
-    def web_url(self) -> Optional[str]:
+    def web_url(self) -> str | None:
         """The URL for the chat in Microsoft Teams. The URL should be treated as an opaque blob, and not parsed."""
         return self.properties.get("webUrl", None)
 
@@ -75,11 +77,7 @@ class Chat(Entity):
         """A collection of all the apps in the chat. Nullable."""
         return self.properties.get(
             "installedApps",
-            EntityCollection(
-                self.context,
-                TeamsAppInstallation,
-                ResourcePath("installedApps", self.resource_path),
-            ),
+            EntityCollection(self.context, TeamsAppInstallation, ResourcePath("installedApps", self.resource_path)),
         )
 
     @odata(name="lastMessagePreview")
@@ -87,8 +85,7 @@ class Chat(Entity):
     def last_message_preview(self) -> ChatMessageInfo:
         """Preview of the last message sent in the chat. Null if no messages have been sent in the chat."""
         return self.properties.get(
-            "lastMessagePreview",
-            ChatMessageInfo(self.context, ResourcePath("lastMessagePreview", self.resource_path)),
+            "lastMessagePreview", ChatMessageInfo(self.context, ResourcePath("lastMessagePreview", self.resource_path))
         )
 
     @odata(name="members", persist=True)
@@ -96,16 +93,14 @@ class Chat(Entity):
     def members(self) -> ConversationMemberCollection:
         """A collection of membership records associated with the chat."""
         return self.properties.setdefault(
-            "members",
-            ConversationMemberCollection(self.context, ResourcePath("members", self.resource_path)),
+            "members", ConversationMemberCollection(self.context, ResourcePath("members", self.resource_path))
         )
 
     @property
-    def messages(self) -> EntityCollection[ChatMessage]:
+    def messages(self) -> ChatMessageCollection:
         """A collection of all the messages in the chat. Nullable."""
         return self.properties.get(
-            "messages",
-            EntityCollection(self.context, ChatMessage, ResourcePath("messages", self.resource_path)),
+            "messages", ChatMessageCollection(self.context, ResourcePath("messages", self.resource_path))
         )
 
     @property
@@ -115,17 +110,31 @@ class Chat(Entity):
         """
         return self.properties.get(
             "operations",
-            EntityCollection(
-                self.context,
-                TeamsAsyncOperation,
-                ResourcePath("operations", self.resource_path),
-            ),
+            EntityCollection(self.context, TeamsAsyncOperation, ResourcePath("operations", self.resource_path)),
         )
 
     @property
     def tabs(self) -> EntityCollection[TeamsTab]:
         """A collection of all the tabs in the chat."""
         return self.properties.get(
-            "tabs",
-            EntityCollection(self.context, TeamsTab, ResourcePath("tabs", self.resource_path)),
+            "tabs", EntityCollection(self.context, TeamsTab, ResourcePath("tabs", self.resource_path))
+        )
+
+    @property
+    def original_created_date_time(self) -> datetime | None:
+        """Gets the originalCreatedDateTime property"""
+        return self.properties.get("originalCreatedDateTime", datetime.min)
+
+    @property
+    def permission_grants(self) -> EntityCollection[ResourceSpecificPermissionGrant]:
+        """Gets the permissionGrants property"""
+        return self.properties.get(
+            "permissionGrants",
+            EntityCollection[ResourceSpecificPermissionGrant](
+                self.context, ResourceSpecificPermissionGrant, ResourcePath("permissionGrants", self.resource_path)
+            ),
         )
+
+    @property
+    def entity_type_name(self) -> str:
+        return "microsoft.graph.Chat"

office365/teams/chats/collection.py

@@ -1,8 +1,12 @@
+from __future__ import annotations
+
 from typing import List, Optional, Union
 
 from office365.entity_collection import EntityCollection
 from office365.runtime.queries.create_entity import CreateEntityQuery
+from office365.runtime.queries.function import FunctionQuery
 from office365.teams.chats.chat import Chat
+from office365.teams.chats.messages.collection import ChatMessageCollection
 from office365.teams.chats.type import ChatType
 
 
@@ -41,3 +45,18 @@ class ChatCollection(EntityCollection[Chat]):
         qry = CreateEntityQuery(self, return_type, return_type)
         self.context.add_query(qry)
         return return_type
+
+    def get_all_messages(self) -> ChatMessageCollection:
+        """Export every chat message visible to the collection scope.
+
+        Works for the tenant scope (``GET /chats/getAllMessages``) and a user's
+        chats (``GET /users/{id}/chats/getAllMessages``). Application-only
+        (``Teamwork.Migrate.All``). Deferred — run with ``execute_query()``.
+
+        Chain ``.filter(...)``/``.select(...)``/``.top(...)`` on the returned
+        collection to shape the request.
+        """
+        return_type = ChatMessageCollection(self.context, self.resource_path)
+        qry = FunctionQuery(self, "getAllMessages", None, return_type)
+        self.context.add_query(qry)
+        return return_type

office365/teams/chats/messages/body.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+from office365.runtime.client_value import ClientValue
+from office365.runtime.odata.json_format import ODataJsonFormat
+
+
+@dataclass
+class ChatMessageBody(ClientValue):
+    """The plain-text or rich-text content of a chat/channel message.
+
+    Teams messages expect a ``chatMessageBody`` payload but reject an explicit
+    OData type marker for it, so :meth:`to_json` emits the fields without the
+    type metadata and lets the service infer the type.
+    """
+
+    content: str | None = None
+    contentType: str | None = None
+
+    def to_json(self, json_format: ODataJsonFormat | None = None) -> dict[str, Any]:
+        result: dict[str, Any] = {}
+        if self.content is not None:
+            result["content"] = self.content
+        if self.contentType is not None:
+            result["contentType"] = self.contentType
+        return result
+
+    @property
+    def entity_type_name(self) -> str:
+        return "Microsoft.Teams.GraphSvc.chatMessageBody"

office365/teams/chats/messages/collection.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+from typing_extensions import Self
+
+from office365.delta_collection import DeltaCollection
+from office365.teams.chats.messages.body import ChatMessageBody
+from office365.teams.chats.messages.message import ChatMessage
+
+
+class ChatMessageCollection(DeltaCollection[ChatMessage]):
+    """Chat message's collection"""
+
+    def __init__(self, context, resource_path=None):
+        super().__init__(context, ChatMessage, resource_path)
+
+    def add(self, content: str) -> ChatMessage:
+        return super().add(body=ChatMessageBody(content=content))
+
+    def download_hosted_contents(self, target_dir: str | os.PathLike) -> Self:
+        """Download inline images (hosted contents) of the loaded messages.
+
+        Deferred like the other export adapters — the download runs on
+        ``execute_query()``::
+
+            >>> channel.messages.get_all().download_hosted_contents("out/attachments").execute_query()
+
+        Args:
+            target_dir: Directory the files are written to (created if missing).
+        """
+
+        def _download(_) -> None:
+            target = Path(target_dir)
+            target.mkdir(parents=True, exist_ok=True)
+            for message in self:
+                for content in message.hosted_contents:
+                    extension = (content.content_type or "application/octet-stream").split("/")[-1].split("+")[0]
+                    name = f"{message.id}_{content.id}.{extension}"
+                    (target / name).write_bytes(content.get_content().execute_query().value)
+
+        return self.after_execute(_download)

office365/teams/chats/messages/hosted_content.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+from typing import AnyStr
+
+from office365.entity import Entity
+from office365.runtime.client_result import ClientResult
+from office365.runtime.queries.function import FunctionQuery
+
+
+class ChatMessageHostedContent(Entity):
+    """Content in a chat or channel message hosted by Teams (e.g. an inline image)."""
+
+    @property
+    def content_type(self) -> str | None:
+        """The media type of the hosted content (e.g. ``image/png``)."""
+        return self.properties.get("contentType")
+
+    def get_content(self) -> ClientResult[AnyStr]:
+        """Download the hosted content bytes (``.../hostedContents/{id}/$value``)."""
+        return_type = ClientResult[AnyStr](self.context)
+        qry = FunctionQuery(self, "$value", None, return_type, return_raw_content=True)
+        self.context.add_query(qry)
+        return return_type
+
+    @property
+    def entity_type_name(self) -> str:
+        return "microsoft.graph.chatMessageHostedContent"

office365/teams/chats/messages/message.py

@@ -3,15 +3,19 @@ from __future__ import annotations
 from datetime import datetime
 from typing import Optional
 
+from office365.directory.permissions.identity_set import IdentitySet
 from office365.entity import Entity
 from office365.entity_collection import EntityCollection
-from office365.outlook.mail.item_body import ItemBody
 from office365.runtime.client_value_collection import ClientValueCollection
 from office365.runtime.paths.resource_path import ResourcePath
 from office365.runtime.types.odata_property import odata
 from office365.teams.channels.iIdentity import ChannelIdentity
 from office365.teams.chats.event_message_detail import EventMessageDetail
 from office365.teams.chats.messages.attachment import ChatMessageAttachment
+from office365.teams.chats.messages.body import ChatMessageBody
+from office365.teams.chats.messages.hosted_content import ChatMessageHostedContent
+from office365.teams.chats.messages.mention import ChatMessageMention
+from office365.teams.chats.messages.reaction import ChatMessageReaction
 
 
 class ChatMessage(Entity):
@@ -26,12 +30,12 @@ class ChatMessage(Entity):
         return self.properties.get("attachments", ClientValueCollection(ChatMessageAttachment))
 
     @property
-    def body(self) -> ItemBody:
+    def body(self) -> ChatMessageBody:
         """
         Plaintext/HTML representation of the content of the chat message. Representation is specified by the
         contentType inside the body. The content is always in HTML if the chat message contains a chatMessageMention.
         """
-        return self.properties.get("body", ItemBody())
+        return self.properties.get("body", ChatMessageBody())
 
     @odata(name="channelIdentity")
     @property
@@ -54,6 +58,67 @@ class ChatMessage(Entity):
         """Timestamp of when the chat message was created."""
         return self.properties.get("createdDateTime", datetime.min)
 
+    @odata(name="lastModifiedDateTime")
+    @property
+    def last_modified_datetime(self) -> datetime:
+        """Timestamp of when the chat message was last modified."""
+        return self.properties.get("lastModifiedDateTime", datetime.min)
+
+    @property
+    def etag(self) -> Optional[str]:
+        """Version marker for the chat message."""
+        return self.properties.get("etag", None)
+
+    @odata(name="from")
+    @property
+    def from_(self) -> IdentitySet:
+        """Details of the sender of the chat message."""
+        return self.properties.get("from", IdentitySet())
+
+    @property
+    def reply_to_id(self) -> Optional[str]:
+        """Id of the parent/root message when this message is a reply."""
+        return self.properties.get("replyToId", None)
+
+    @property
+    def message_type(self) -> Optional[str]:
+        """The type of the chat message (``message``, ``systemEventMessage``, ...)."""
+        return self.properties.get("messageType", None)
+
+    @property
+    def mentions(self) -> ClientValueCollection[ChatMessageMention]:
+        """The mentions for the chat message."""
+        return self.properties.get("mentions", ClientValueCollection(ChatMessageMention))
+
+    @property
+    def reactions(self) -> ClientValueCollection[ChatMessageReaction]:
+        """The reactions for the chat message."""
+        return self.properties.get("reactions", ClientValueCollection(ChatMessageReaction))
+
+    @property
+    def hosted_contents(self) -> EntityCollection[ChatMessageHostedContent]:
+        """Content hosted by Teams as part of the message (e.g. inline images).
+
+        Graph inlines these as plain objects, so normalize the raw list into a
+        typed collection for convenient navigation (``id``, ``get_content()``).
+        """
+        value = self.properties.get("hostedContents")
+        if isinstance(value, list):
+            collection = EntityCollection(
+                self.context, ChatMessageHostedContent, ResourcePath("hostedContents", self.resource_path)
+            )
+            for index, item in enumerate(value):
+                if isinstance(item, dict):
+                    collection.set_property(str(index), item, False)
+                else:
+                    collection.add_child(item)
+            return collection
+        if value is None:
+            return EntityCollection(
+                self.context, ChatMessageHostedContent, ResourcePath("hostedContents", self.resource_path)
+            )
+        return value
+
     @odata(name="deletedDateTime")
     @property
     def deleted_datetime(self) -> datetime:

office365/teams/class_settings.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from office365.runtime.client_value import ClientValue
+
+
+@dataclass
+class TeamClassSettings(ClientValue):
+    notifyGuardiansAboutAssignments: bool | None = None
+
+    @property
+    def entity_type_name(self) -> str:
+        return "microsoft.graph.TeamClassSettings"