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

office365/teams/schedule/time_off_reason_icon_type.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+from enum import Enum
+
+
+class TimeOffReasonIconType(Enum):
+    none = "0"
+    car = "1"
+    calendar = "2"
+    running = "3"
+    plane = "4"
+    firstAid = "5"
+    doctor = "6"
+    notWorking = "7"
+    clock = "8"
+    juryDuty = "9"
+    globe = "10"
+    cup = "11"
+    phone = "12"
+    weather = "13"
+    umbrella = "14"
+    piggyBank = "15"
+    dog = "16"
+    cake = "17"
+    trafficCone = "18"
+    pin = "19"
+    sunny = "20"
+    unknownFutureValue = "21"
+
+    @property
+    def entity_type_name(self) -> str:
+        return "microsoft.graph.TimeOffReasonIconType"

office365/teams/tabs/updated_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 TabUpdatedEventMessageDetail(ClientValue):
+    initiator: IdentitySet = field(default_factory=IdentitySet)
+    tabId: str | None = None
+
+    @property
+    def entity_type_name(self) -> str:
+        return "microsoft.graph.TabUpdatedEventMessageDetail"

office365/teams/team.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from datetime import datetime
-from typing import Any, Dict, Optional
+from typing import Any
 
 import requests
 from typing_extensions import Self
@@ -23,8 +23,7 @@ from office365.teams.guest_settings import TeamGuestSettings
 from office365.teams.members.conversation_collection import ConversationMemberCollection
 from office365.teams.members.settings import TeamMemberSettings
 from office365.teams.messaging_settings import TeamMessagingSettings
-from office365.teams.operations.async_operation import TeamsAsyncOperation
-from office365.teams.operations.async_status import TeamsAsyncOperationStatus
+from office365.teams.operations.async_operation import TeamsAsyncOperation, wait_for_operation
 from office365.teams.schedule.schedule import Schedule
 from office365.teams.specialization import TeamSpecialization
 from office365.teams.summary import TeamSummary
@@ -41,25 +40,10 @@ class Team(Entity):
 
     def __init__(self, context, resource_path=None):
         super().__init__(context, resource_path)
-        self._pending_operation: TeamsAsyncOperation | None = None
 
     def __str__(self):
         return self.display_name or self.entity_type_name
 
-    def execute_query_and_wait(self) -> Self:
-        """
-        Submit request(s) to the server and waits until operation is completed
-        """
-
-        def _loaded():
-            if self._pending_operation is None:
-                raise RuntimeError("No pending async operation to wait for. Call clone() or create() first.")
-            self._pending_operation.poll_for_status(status_type=TeamsAsyncOperationStatus.succeeded)
-
-        self.ensure_property("id").after_execute(lambda _: _loaded())
-        self.execute_query()
-        return self
-
     def delete_object(self, permanent_delete=False):
         """Deletes a team"""
 
@@ -96,26 +80,26 @@ class Team(Entity):
         return self.properties.get("guestSettings", TeamMessagingSettings())
 
     @property
-    def display_name(self) -> Optional[str]:
+    def display_name(self) -> str | None:
         """The name of the team."""
-        return self.properties.get("displayName", None)
+        return self.properties.get("displayName")
 
     @property
-    def description(self) -> Optional[str]:
+    def description(self) -> str | None:
         """An optional description for the team."""
-        return self.properties.get("description", None)
+        return self.properties.get("description")
 
     @property
-    def classification(self) -> Optional[str]:
+    def classification(self) -> str | None:
         """An optional label. Typically describes the data or business sensitivity of the team.
         Must match one of a pre-configured set in the tenant's directory.
         """
-        return self.properties.get("classification", None)
+        return self.properties.get("classification")
 
     @property
-    def is_archived(self) -> Optional[bool]:
+    def is_archived(self) -> bool | None:
         """Whether this team is in read-only mode."""
-        return self.properties.get("isArchived", None)
+        return self.properties.get("isArchived")
 
     @property
     def visibility(self) -> TeamVisibilityType:
@@ -123,17 +107,17 @@ class Team(Entity):
         return self.properties.get("visibility", TeamVisibilityType.unknown)
 
     @property
-    def web_url(self) -> Optional[str]:
+    def web_url(self) -> str | None:
         """A hyperlink that will go to the team in the Microsoft Teams client. This is the URL that you get when
         you right-click a team in the Microsoft Teams client and select Get link to team. This URL should be treated
         as an opaque blob, and not parsed."""
-        return self.properties.get("webUrl", None)
+        return self.properties.get("webUrl")
 
     @odata(name="createdDateTime")
     @property
     def created_datetime(self):
         """Timestamp at which the team was created."""
-        return self.properties.get("createdDateTime", None)
+        return self.properties.get("createdDateTime")
 
     @odata(name="allChannels")
     @property
@@ -214,9 +198,9 @@ class Team(Entity):
         return self.properties.get("summary", TeamSummary())
 
     @property
-    def tenant_id(self) -> Optional[str]:
+    def tenant_id(self) -> str | None:
         """The ID of the Azure Active Directory tenant."""
-        return self.properties.get("tenantId", None)
+        return self.properties.get("tenantId")
 
     @property
     def tags(self) -> EntityCollection[TeamworkTag]:
@@ -237,14 +221,14 @@ class Team(Entity):
         return self.properties.get("createdDateTime", datetime.min)
 
     @property
-    def first_channel_name(self) -> Optional[str]:
+    def first_channel_name(self) -> str | None:
         """Gets the firstChannelName property"""
-        return self.properties.get("firstChannelName", None)
+        return self.properties.get("firstChannelName")
 
     @property
-    def internal_id(self) -> Optional[str]:
+    def internal_id(self) -> str | None:
         """Gets the internalId property"""
-        return self.properties.get("internalId", None)
+        return self.properties.get("internalId")
 
     @property
     def specialization(self) -> TeamSpecialization:
@@ -287,17 +271,30 @@ class Team(Entity):
         visibility: TeamVisibilityType,
         description: str | None = None,
         classification: str | None = None,
-    ) -> Self:
-        """Create a copy of a team. This operation also creates a copy of the corresponding group.
+    ) -> TeamsAsyncOperation:
+        """Create a copy of a team (async) — returns the ``teamsAsyncOperation``.
+
+        The operation is submitted on ``execute_query()`` (HTTP 202). Poll the
+        returned operation (:meth:`TeamsAsyncOperation.poll_for_status`) to wait
+        for provisioning; ``target_resource_id`` then holds the cloned team id.
+        Use :meth:`clone_and_wait` for the convenience path that returns the
+        ready cloned team.
 
         Args:
+            mail_nickname: The mail nickname for the cloned team.
             display_name: The display name for the cloned team.
             parts_to_clone: The parts of the team to clone.
             visibility: The visibility of the cloned team.
             description: The description for the cloned team.
-            mail_nickname: The mail nickname for the cloned team.
             classification: The classification for the cloned team.
         """
+        return_type = TeamsAsyncOperation(self.context)
+
+        def _process_response(resp: requests.Response) -> None:
+            loc = resp.headers.get("Location")
+            if loc is not None:
+                return_type._resource_path = ODataPathBuilder.parse_url(loc)
+
         payload = {
             "displayName": display_name,
             "partsToClone": parts_to_clone.name,
@@ -310,17 +307,62 @@ class Team(Entity):
         if classification is not None:
             payload["classification"] = classification
         qry = ServiceOperationQuery(self, "clone", None, payload, None, None)
+        self.context.add_query(qry).after_execute(_process_response, include_response=True)
+        return return_type
+
+    def clone_and_wait(
+        self,
+        mail_nickname: str,
+        display_name: str,
+        parts_to_clone: ClonableTeamParts,
+        visibility: TeamVisibilityType,
+        description: str | None = None,
+        classification: str | None = None,
+    ) -> Team:
+        """Clone a team and wait for provisioning (deferred).
+
+        Chains the async clone, the ``teamsAsyncOperation`` poll, and a full
+        ``GET`` of the cloned team through ``after_execute`` hooks — one
+        ``execute_query()`` returns the provisioned cloned :class:`Team` with its
+        properties loaded.
+
+        Args:
+            mail_nickname: The mail nickname for the cloned team.
+            display_name: The display name for the cloned team.
+            parts_to_clone: The parts of the team to clone.
+            visibility: The visibility of the cloned team.
+            description: The description for the cloned team.
+            classification: The classification for the cloned team.
+        """
+        return_type = Team(self.context)
+        self.context.teams.add_child(return_type)
 
         def _process_response(resp: requests.Response) -> None:
-            loc = resp.headers.get("Location", None)
-            if loc is not None:
-                operation_path = ODataPathBuilder.parse_url(loc)
-                operation = TeamsAsyncOperation(self.context, operation_path)
-                self.operations.add_child(operation)
-                self._pending_operation = operation
+            loc = resp.headers.get("Location")
+            assert loc is not None
+            operation = TeamsAsyncOperation(self.context, ODataPathBuilder.parse_url(loc))
 
+            def _on_succeeded(op: TeamsAsyncOperation) -> None:
+                if op.target_resource_id:
+                    return_type.set_property("id", op.target_resource_id, False)
+                return_type.get()  # queue a full GET to load the cloned team's properties
+
+            wait_for_operation(operation, success_callback=_on_succeeded)
+
+        payload = {
+            "displayName": display_name,
+            "partsToClone": parts_to_clone.name,
+            "visibility": visibility.name,
+        }
+        if description is not None:
+            payload["description"] = description
+        if mail_nickname is not None:
+            payload["mailNickname"] = mail_nickname
+        if classification is not None:
+            payload["classification"] = classification
+        qry = ServiceOperationQuery(self, "clone", None, payload, None, None)
         self.context.add_query(qry).after_execute(_process_response, include_response=True)
-        return self
+        return return_type
 
     def send_activity_notification(
         self,
@@ -328,7 +370,7 @@ class Team(Entity):
         activity_type: str,
         chain_id: str,
         preview_text: str,
-        template_parameters: Dict[str, Any],
+        template_parameters: dict[str, Any],
         recipient: TeamworkNotificationRecipient,
     ):
         """Send an activity feed notification in the scope of a team.

office365/teams/teamwork/application_identity.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from office365.runtime.client_value import ClientValue
+from office365.teams.teamwork.applicationidentitytype import TeamworkApplicationIdentityType
+
+
+@dataclass
+class TeamworkApplicationIdentity(ClientValue):
+    applicationIdentityType: TeamworkApplicationIdentityType = TeamworkApplicationIdentityType.aadApplication
+
+    @property
+    def entity_type_name(self) -> str:
+        return "microsoft.graph.TeamworkApplicationIdentity"

office365/teams/teamwork/shiftmanagement/user_solution_root.py

@@ -3,3 +3,7 @@ from office365.entity import Entity
 
 class UserSolutionRoot(Entity):
     """Represents an identifier that relates a user to the working time schedule triggers."""
+
+    @property
+    def entity_type_name(self) -> str:
+        return "microsoft.graph.UserSolutionRoot"

office365/teams/teamwork/user.py

@@ -43,11 +43,7 @@ class UserTeamwork(Entity):
         """
         return self.properties.get(
             "associatedTeams",
-            EntityCollection(
-                self.context,
-                AssociatedTeamInfo,
-                ResourcePath("associatedTeams", self.resource_path),
-            ),
+            EntityCollection(self.context, AssociatedTeamInfo, ResourcePath("associatedTeams", self.resource_path)),
         )
 
     @odata(name="installedApps")
@@ -59,9 +55,7 @@ class UserTeamwork(Entity):
         return self.properties.get(
             "installedApps",
             EntityCollection(
-                self.context,
-                UserScopeTeamsAppInstallation,
-                ResourcePath("installedApps", self.resource_path),
+                self.context, UserScopeTeamsAppInstallation, ResourcePath("installedApps", self.resource_path)
             ),
         )
 
@@ -89,3 +83,7 @@ class UserTeamwork(Entity):
         qry = ServiceOperationQuery(self, "sendActivityNotification", None, payload)
         self.context.add_query(qry)
         return self
+
+    @property
+    def entity_type_name(self) -> str:
+        return "microsoft.graph.UserTeamwork"

office365/teams/teamwork/workforce_integration_encryption_protocol.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+from enum import Enum
+
+
+class WorkforceIntegrationEncryptionProtocol(Enum):
+    sharedSecret = "0"
+    unknownFutureValue = "1"
+
+    @property
+    def entity_type_name(self) -> str:
+        return "microsoft.graph.WorkforceIntegrationEncryptionProtocol"

office365/teams/teamwork/workforce_integration_supported_entities.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+from enum import Enum
+
+
+class WorkforceIntegrationSupportedEntities(Enum):
+    none = "0"
+    shift = "1"
+    swapRequest = "2"
+    userShiftPreferences = "8"
+    openShift = "16"
+    openShiftRequest = "32"
+    offerShiftRequest = "64"
+    unknownFutureValue = "1024"
+    timeCard = "2048"
+    timeOffReason = "4096"
+    timeOff = "8192"
+    timeOffRequest = "16384"
+
+    @property
+    def entity_type_name(self) -> str:
+        return "microsoft.graph.WorkforceIntegrationSupportedEntities"

office365/teams/unarchived_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 TeamUnarchivedEventMessageDetail(ClientValue):
+    initiator: IdentitySet = field(default_factory=IdentitySet)
+    teamId: str | None = None
+
+    @property
+    def entity_type_name(self) -> str:
+        return "microsoft.graph.TeamUnarchivedEventMessageDetail"

office365/teams/viva/employee_experience_user.py

@@ -13,8 +13,10 @@ class EmployeeExperienceUser(Entity):
         return self.properties.get(
             "learningCourseActivities",
             EntityCollection(
-                self.context,
-                LearningCourseActivity,
-                ResourcePath("learningCourseActivities", self.resource_path),
+                self.context, LearningCourseActivity, ResourcePath("learningCourseActivities", self.resource_path)
             ),
         )
+
+    @property
+    def entity_type_name(self) -> str:
+        return "microsoft.graph.EmployeeExperienceUser"

office365/todo/attachments/collection.py

@@ -1,10 +1,85 @@
+from __future__ import annotations
+
+import base64
+from typing import Optional, Union
+
+from office365.directory.permissions.require_permission import require_permission
 from office365.entity_collection import EntityCollection
+from office365.runtime.paths.v4.entity import EntityPath
+from office365.runtime.queries.create_entity import CreateEntityQuery
+from office365.runtime.queries.service_operation import ServiceOperationQuery
 from office365.todo.attachments.base import AttachmentBase
+from office365.todo.attachments.info import AttachmentInfo
+from office365.todo.attachments.session import AttachmentSession
+from office365.todo.attachments.task_file import TaskFileAttachment
+from office365.todo.attachments.type import AttachmentType
 
 
-class AttachmentBaseCollection(EntityCollection):
+class AttachmentBaseCollection(EntityCollection[AttachmentBase]):
+    """Attachment's collection"""
+
     def __init__(self, context, resource_path=None):
         super().__init__(context, AttachmentBase, resource_path)
 
-    def create_upload_session(self):
-        pass
+    @require_permission(delegated=["Tasks.ReadWrite"])
+    def add(
+        self,
+        name: str,
+        content: Union[bytes, bytearray, str],
+        content_type: Optional[str] = None,
+        size: Optional[int] = None,
+    ) -> TaskFileAttachment:
+        """Add a file attachment (up to 3 MB) to a task.
+
+        Args:
+            name (str): Display name of the attachment.
+            content (bytes or str): Raw bytes (base64-encoded automatically) or an
+              already base64-encoded string.
+            content_type (str): MIME type of the attachment.
+            size (int): Size in bytes (defaults to ``len(content)`` for raw bytes).
+        """
+        if isinstance(content, (bytes, bytearray)):
+            size = len(content) if size is None else size
+            content_bytes = base64.b64encode(bytes(content)).decode("ascii")
+        else:
+            content_bytes = content
+
+        return_type = TaskFileAttachment(self.context, EntityPath(None, self.resource_path))
+        return_type.set_property("name", name)
+        return_type.set_property("contentBytes", content_bytes)
+        if content_type is not None:
+            return_type.set_property("contentType", content_type)
+        if size is not None:
+            return_type.set_property("size", size)
+
+        self.add_child(return_type)
+        qry = CreateEntityQuery(self, return_type, return_type)
+        self.context.add_query(qry)
+        return return_type
+
+    @require_permission(delegated=["Tasks.ReadWrite"])
+    def create_upload_session(
+        self,
+        name: str,
+        size: int,
+        content_type: Optional[str] = None,
+    ) -> AttachmentSession:
+        """Create an upload session for a file larger than 3 MB (up to 25 MB).
+
+        Args:
+            name (str): Display name of the attachment.
+            size (int): Size in bytes of the file to upload.
+            content_type (str): MIME type of the file.
+        """
+        attachment_info = AttachmentInfo(
+            attachmentType=AttachmentType.file,
+            contentType=content_type,
+            name=name,
+            size=size,
+        )
+        return_type = AttachmentSession(self.context)
+        qry = ServiceOperationQuery(
+            self, "createUploadSession", None, {"attachmentInfo": attachment_info}, None, return_type
+        )
+        self.context.add_query(qry)
+        return return_type

office365/todo/attachments/info.py

@@ -1,5 +1,21 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Optional
+
 from office365.runtime.client_value import ClientValue
+from office365.todo.attachments.type import AttachmentType
 
 
+@dataclass
 class AttachmentInfo(ClientValue):
-    """Represents the attributes of an attachment."""
+    """Represents the attributes of an attachment to be uploaded to a todoTask."""
+
+    attachmentType: Optional[AttachmentType] = None
+    contentType: Optional[str] = None
+    name: Optional[str] = None
+    size: Optional[int] = None
+
+    @property
+    def entity_type_name(self) -> str:
+        return "microsoft.graph.attachmentInfo"

office365/todo/attachments/session.py

@@ -1,13 +1,30 @@
+from __future__ import annotations
+
+import io
+import os
 from datetime import datetime
+from os import PathLike
+from typing import IO, Optional, Union
 
 from office365.entity import Entity
+from office365.runtime.odata.v4.upload_session_request import UploadSessionRequest
+from office365.runtime.operations import Progress, ProgressCallback
+from office365.runtime.queries.client_query import ClientQuery
 from office365.runtime.types.collections import StringCollection
 from office365.runtime.types.odata_property import odata
+from office365.todo.attachments.task_file import TaskFileAttachment
+
+DEFAULT_CHUNK_SIZE = 4 * 1024 * 1024
 
 
 class AttachmentSession(Entity):
     """Represents a resource that uploads large attachments to a todoTask."""
 
+    @property
+    def upload_url(self) -> Optional[str]:
+        """The URL that allows uploading ranges of bytes to the attachment."""
+        return self.properties.get("uploadUrl", None)
+
     @property
     def content(self):
         """The content streams that are uploaded."""
@@ -26,3 +43,60 @@ class AttachmentSession(Entity):
         """Indicates a single value {start} that represents the location in the file where the next
         upload should begin."""
         return self.properties.get("nextExpectedRanges", StringCollection())
+
+    def upload(
+        self,
+        source: Union[str, PathLike, bytes, bytearray, IO],
+        chunk_size: int = DEFAULT_CHUNK_SIZE,
+        progress: Optional[ProgressCallback] = None,
+    ) -> TaskFileAttachment:
+        """Upload a file (path, bytes, or stream) to this session and return the created attachment.
+
+        Ranges are sent sequentially (``PUT`` with ``Content-Range``) until the whole
+        file is uploaded, as required by the Microsoft Graph upload-session contract.
+
+        Args:
+            source: Path, raw bytes, or a binary stream.
+            chunk_size: Maximum bytes per ``PUT`` (4 MB by default).
+            progress: Optional hook invoked per chunk with a ``Progress`` snapshot.
+        """
+        auto_close = False
+        if isinstance(source, (str, PathLike)):
+            file_object: IO = open(source, "rb")
+            file_size: Optional[int] = os.path.getsize(source)
+            auto_close = True
+        elif isinstance(source, (bytes, bytearray)):
+            file_object = io.BytesIO(bytes(source))
+            file_size = len(source)
+        else:
+            file_object = source
+            file_size = None
+
+        def _chunk_uploaded(uploaded: int) -> None:
+            if callable(progress):
+                progress(Progress(done=uploaded, total=file_size, stage="uploading"))
+
+        request = UploadSessionRequest(
+            file_object,
+            chunk_size,
+            chunk_uploaded=_chunk_uploaded,
+            upload_url=self.upload_url,
+            file_size=file_size,
+        )
+        request.transport = self.context.pending_request().transport
+        try:
+            request.execute_query(ClientQuery(self.context))
+        finally:
+            if auto_close and not file_object.closed:
+                file_object.close()
+
+        attachment = TaskFileAttachment(self.context)
+        response = request.last_response
+        if response is not None and response.content:
+            try:
+                payload = response.json()
+            except ValueError:
+                payload = {}
+            for key, value in payload.items():
+                attachment.set_property(key, value, False)
+        return attachment

office365/todo/attachments/type.py

@@ -1,2 +1,14 @@
-class AttachmentType:
-    """"""
+from enum import Enum
+
+
+class AttachmentType(Enum):
+    """The type of a Microsoft To Do attachment."""
+
+    file = "file"
+    item = "item"
+    reference = "reference"
+    unknownFutureValue = "unknownFutureValue"
+
+    @property
+    def entity_type_name(self) -> str:
+        return "microsoft.graph.attachmentType"

office365/todo/linked_resource.py

@@ -18,3 +18,13 @@ class LinkedResource(Entity):
     def display_name(self) -> Optional[str]:
         """The title of the linkedResource."""
         return self.properties.get("displayName", None)
+
+    @property
+    def external_id(self) -> Optional[str]:
+        """The identifier of the object in the source application."""
+        return self.properties.get("externalId", None)
+
+    @property
+    def web_url(self) -> Optional[str]:
+        """The deep link to the related item in the source application."""
+        return self.properties.get("webUrl", None)