Office365-REST-Python-Client 2.6.1__py3-none-any.whl → 2.6.2__py3-none-any.whl

office365/onedrive/workbooks/ranges/range.py

@@ -120,6 +120,12 @@ class WorkbookRange(Entity):
         """Represents the column number of the first cell in the range. Zero-indexed. Read-only."""
         return self.properties.get("columnIndex", None)
 
+    @property
+    def row_index(self):
+        # type: () -> Optional[int]
+        """Returns the row number of the first cell in the range. Zero-indexed. Read-only."""
+        return self.properties.get("rowIndex", None)
+
     @property
     def format(self):
         """Returns a format object, encapsulating the range's font, fill, borders, alignment, and other properties"""

office365/onedrive/workbooks/worksheets/protection_options.py

@@ -5,11 +5,40 @@ class WorkbookWorksheetProtectionOptions(ClientValue):
     """Represents the protection of a sheet object."""
 
     def __init__(
-        self, allowAutoFilter=None, allowDeleteColumns=None, allowDeleteRows=None
+        self,
+        allow_auto_filter=None,
+        allow_delete_columns=None,
+        allow_delete_rows=None,
+        allow_format_cells=None,
+        allow_format_columns=None,
+        allow_format_rows=None,
+        allow_insert_columns=None,
+        allow_insert_hyperlinks=None,
+        allow_insert_rows=None,
+        allow_pivot_tables=None,
+        allow_sort=None,
     ):
         """
-        :param bool allowAutoFilter:
+        :param bool allow_auto_filter: Represents the worksheet protection option of allowing using auto filter feature.
+        :param bool allow_delete_columns: Represents the worksheet protection option of allowing deleting columns.
+        :param bool allow_delete_rows: Represents the worksheet protection option of allowing deleting rows.
+        :param bool allow_format_cells: Represents the worksheet protection option of allowing formatting cells.
+        :param bool allow_format_columns: Represents the worksheet protection option of allowing formatting columns.
+        :param bool allow_format_rows: Represents the worksheet protection option of allowing formatting rows.
+        :param bool allow_insert_columns: Represents the worksheet protection option of allowing inserting columns.
+        :param bool allow_insert_hyperlinks: Represents the worksheet protection option of allowing inserting hyperlinks.
+        :param bool allow_insert_rows: Represents the worksheet protection option of allowing inserting rows.
+        :param bool allow_pivot_tables: Represents the worksheet protection option of allowing using pivot table feature.
+        :param bool allow_sort: Represents the worksheet protection option of allowing sorting.
         """
-        self.allowAutoFilter = allowAutoFilter
-        self.allowDeleteColumns = allowDeleteColumns
-        self.allowDeleteRows = allowDeleteRows
+        self.allowAutoFilter = allow_auto_filter
+        self.allowDeleteColumns = allow_delete_columns
+        self.allowDeleteRows = allow_delete_rows
+        self.allowFormatCells = allow_format_cells
+        self.allowFormatColumns = allow_format_columns
+        self.allowFormatRows = allow_format_rows
+        self.allowInsertColumns = allow_insert_columns
+        self.allowInsertHyperlinks = allow_insert_hyperlinks
+        self.allowInsertRows = allow_insert_rows
+        self.allowPivotTables = allow_pivot_tables
+        self.allowSort = allow_sort

office365/outlook/calendar/events/event.py

@@ -78,6 +78,16 @@ class Event(OutlookItem):
         self.context.add_query(qry)
         return self
 
+    def permanent_delete(self):
+        """
+        Permanently delete an event and place it in the purges folder in the dumpster in the user's mailbox.
+        Email clients such as outlook or outlook on the web can't access permanently deleted items.
+        Unless there's a hold set on the mailbox, the items are permanently deleted after a set period of time.
+        """
+        qry = ServiceOperationQuery(self, "permanentDelete")
+        self.context.add_query(qry)
+        return self
+
     @property
     def allow_new_time_proposals(self):
         # type: () -> Optional[bool]
@@ -126,6 +136,53 @@ class Event(OutlookItem):
         """
         return self.properties.get("isAllDay", None)
 
+    @property
+    def is_cancelled(self):
+        # type: () -> Optional[bool]
+        """
+        Set to true if the event has been canceled.
+        """
+        return self.properties.get("isCancelled", None)
+
+    @property
+    def is_draft(self):
+        # type: () -> Optional[bool]
+        """
+        Set to true if the user has updated the meeting in Outlook but hasn't sent the updates to attendees.
+        Set to false if all changes are sent, or if the event is an appointment without any attendees.
+        """
+        return self.properties.get("isDraft", None)
+
+    @property
+    def is_online_meeting(self):
+        # type: () -> Optional[bool]
+        """
+        True if this event has online meeting information
+        (that is, onlineMeeting points to an onlineMeetingInfo resource), false otherwise.
+        Default is false (onlineMeeting is null). Optional.
+        After you set isOnlineMeeting to true, Microsoft Graph initializes onlineMeeting.
+        Subsequently, Outlook ignores any further changes to isOnlineMeeting, and the meeting remains available online.
+        """
+        return self.properties.get("isOnlineMeeting", None)
+
+    @property
+    def is_organizer(self):
+        # type: () -> Optional[bool]
+        """
+        Set to true if the calendar owner (specified by the owner property of the calendar) is the organizer of
+        the event (specified by the organizer property of the event). It also applies if a delegate organized the
+        event on behalf of the owner.
+        """
+        return self.properties.get("isOrganizer", None)
+
+    @property
+    def is_reminder_on(self):
+        # type: () -> Optional[bool]
+        """
+        Set to true if an alert is set to remind the user of the event.
+        """
+        return self.properties.get("isReminderOn", None)
+
     @property
     def start(self):
         """The date, time, and time zone that the event starts. By default, the start time is in UTC."""

office365/outlook/mail/automatic_replies_mailtips.py

@@ -1,5 +1,25 @@
+from office365.outlook.calendar.dateTimeTimeZone import DateTimeTimeZone
+from office365.outlook.locale_info import LocaleInfo
 from office365.runtime.client_value import ClientValue
 
 
 class AutomaticRepliesMailTips(ClientValue):
     """MailTips about any automatic replies that have been set up on a mailbox."""
+
+    def __init__(
+        self,
+        message=None,
+        message_language=LocaleInfo(),
+        scheduled_end_time=DateTimeTimeZone(),
+        scheduled_start_time=DateTimeTimeZone(),
+    ):
+        """
+        :param string message: The automatic reply message.
+        :param LocaleInfo message_language: 	The language that the automatic reply message is in.
+        :param datetime scheduled_end_time: 	The date and time that automatic replies are set to end.
+        :param datetime scheduled_start_time: The date and time that automatic replies are set to begin.
+        """
+        self.message = message
+        self.messageLanguage = message_language
+        self.scheduledEndTime = scheduled_end_time
+        self.scheduledStartTime = scheduled_start_time

office365/outlook/mail/folders/folder.py

@@ -7,7 +7,7 @@ from office365.directory.extensions.extended_property import (
 from office365.entity import Entity
 from office365.entity_collection import EntityCollection
 from office365.outlook.mail.messages.collection import MessageCollection
-from office365.outlook.mail.messages.rules.rule import MessageRule
+from office365.outlook.mail.messages.rules.collection import MessageRuleCollection
 from office365.runtime.paths.resource_path import ResourcePath
 from office365.runtime.queries.service_operation import ServiceOperationQuery
 
@@ -116,13 +116,12 @@ class MailFolder(Entity):
 
     @property
     def message_rules(self):
-        # type: () -> EntityCollection[MessageRule]
+        # type: () -> MessageRuleCollection
         """"""
         return self.properties.get(
             "messageRules",
-            EntityCollection(
+            MessageRuleCollection(
                 self.context,
-                MessageRule,
                 ResourcePath("messageRules", self.resource_path),
             ),
         )

office365/outlook/mail/messages/message.py

@@ -258,11 +258,22 @@ class Message(OutlookItem):
 
     @body.setter
     def body(self, value):
-        # type: (str|ItemBody) -> None
+        # type: (str|ItemBody|tuple) -> None
         """Sets the body of the message. It can be in HTML or text format."""
-        if not isinstance(value, ItemBody):
-            value = ItemBody(value)
-        self.set_property("body", value)
+        content_type = "Text"  # Default content type
+        if isinstance(value, tuple):
+            if len(value) != 2:
+                raise ValueError("value must be a tuple of (content, content_type)")
+            content, content_type = value
+        else:
+            content = value
+        if isinstance(content, ItemBody):
+            self.set_property("body", content)
+            return
+        if content_type.lower() not in ["text", "html"]:
+            raise ValueError("content_type must be either 'Text' or 'HTML'")
+        item_body = ItemBody(content=content, content_type=content_type)
+        self.set_property("body", item_body)
 
     @property
     def body_preview(self):
@@ -407,6 +418,12 @@ class Message(OutlookItem):
             "ccRecipients", ClientValueCollection(Recipient)
         )
 
+    @property
+    def reply_to(self):
+        """The replyTo: recipients for the reply to the message."""
+        self._persist_changes("replyTo")
+        return self.properties.setdefault("replyTo", ClientValueCollection(Recipient))
+
     @property
     def sender(self):
         """The account that is actually used to generate the message. In most cases, this value is the same as the

office365/outlook/mail/messages/rules/collection.py

@@ -0,0 +1,26 @@
+from office365.entity_collection import EntityCollection
+from office365.outlook.mail.messages.rules.rule import MessageRule
+
+
+class MessageRuleCollection(EntityCollection[MessageRule]):
+    def __init__(self, context, resource_path=None):
+        super(MessageRuleCollection, self).__init__(context, MessageRule, resource_path)
+
+    def add(self, display_name, sequence, actions, **kwargs):
+        """
+        Create a messageRule object by specifying a set of conditions and actions.
+        Outlook carries out those actions if an incoming message in the user's Inbox meets the specified conditions.
+        This API is available in the following national cloud deployments.
+
+        :param str display_name: The display name of the rule.
+        :param int sequence: Indicates the order in which the rule is executed, among other rules.
+        :param MessageRuleActions actions: Actions to be taken on a message when the corresponding conditions,
+            if any, are fulfilled.
+        """
+        props = {
+            "displayName": display_name,
+            "sequence": sequence,
+            "actions": actions.to_json(),
+            **kwargs,
+        }
+        return super(MessageRuleCollection, self).add(**props)

office365/outlook/mail/tips/error.py

@@ -0,0 +1,5 @@
+from office365.runtime.client_value import ClientValue
+
+
+class MailTipsError(ClientValue):
+    """"""

office365/outlook/mail/tips/tips.py

@@ -0,0 +1,41 @@
+from office365.outlook.calendar.email_address import EmailAddress
+from office365.outlook.mail.automatic_replies_mailtips import AutomaticRepliesMailTips
+from office365.outlook.mail.tips.error import MailTipsError
+from office365.runtime.client_value import ClientValue
+
+
+class MailTips(ClientValue):
+    """Informative messages about a recipient, that are displayed to users while they're composing a message.
+    For example, an out-of-office message as an automatic reply for a message recipient.
+    """
+
+    def __init__(
+        self,
+        automatic_replies=AutomaticRepliesMailTips(),
+        custom_mail_tip=None,
+        delivery_restricted=None,
+        email_address=EmailAddress(),
+        error=MailTipsError(),
+        external_member_count=None,
+        is_moderated=None,
+    ):
+        """
+        :param AutomaticRepliesMailTips automatic_replies: Mail tips for automatic reply if it has been set up by
+            the recipient.
+        :param str custom_mail_tip: A custom mail tip that can be set on the recipient's mailbox.
+        :param bool delivery_restricted: Whether the recipient is delivery restricted.
+        :param EmailAddress email_address: Email address for the recipient.
+        :param MailTipsError error: Error raised when an error occurs.
+        :param int external_member_count: The number of external members if the recipient is a distribution list.
+        :param bool is_moderated: Whether sending messages to the recipient requires approval. For example,
+            if the recipient is a large distribution list and a moderator has been set up to approve messages sent
+            to that distribution list, or if sending messages to a recipient requires approval
+            of the recipient's manager.
+        """
+        self.automaticReplies = automatic_replies
+        self.customMailTip = custom_mail_tip
+        self.deliveryRestricted = delivery_restricted
+        self.emailAddress = email_address
+        self.error = error
+        self.externalMemberCount = external_member_count
+        self.isModerated = is_moderated

office365/outlook/people/profile_card_property.py

@@ -0,0 +1,15 @@
+from office365.entity import Entity
+
+
+class ProfileCardProperty(Entity):
+    """
+    Represents an attribute of a user on the Microsoft 365 profile card for an organization to surface in a shared,
+    people experience.
+
+    The attribute can be an Microsoft Entra ID built-in attribute, such as Alias or UserPrincipalName,
+    or it can be a custom attribute. For a custom attribute, an administrator can define an en-us default display name
+    String and a set of alternative translations for the languages supported in their organization.
+
+    For more information about how to add properties to the profile card for an organization, see Add or remove
+    custom attributes on a profile card using the profile card API.
+    """

office365/outlook/person.py

@@ -0,0 +1,7 @@
+from office365.entity import Entity
+
+
+class Person(Entity):
+    """Represents an aggregation of information about a person from across mail and contacts.
+    People can be local contacts or your organization's directory, and people from recent communications
+    (such as email)."""

office365/planner/category_descriptions.py

@@ -0,0 +1,6 @@
+from office365.runtime.client_value import ClientValue
+
+
+class PlannerCategoryDescriptions(ClientValue):
+    """Represents the descriptive labels for the categories that have been defined for a plan.
+    It belongs to the plan details object. There can be up to 25 categories defined."""

office365/planner/external_references.py

@@ -0,0 +1,7 @@
+from office365.runtime.client_value import ClientValue
+
+
+class PlannerExternalReferences(ClientValue):
+    """The plannerExternalReferences resource represents the collection of references on a task. This is an Open Type.
+    It's part of the task details object. The value in the property-value pair is the externalReference object.
+    """

office365/planner/planner.py

@@ -2,7 +2,7 @@ from office365.entity import Entity
 from office365.entity_collection import EntityCollection
 from office365.planner.buckets.bucket import PlannerBucket
 from office365.planner.plans.collection import PlannerPlanCollection
-from office365.planner.tasks.task import PlannerTask
+from office365.planner.tasks.collection import PlannerTaskCollection
 from office365.runtime.paths.resource_path import ResourcePath
 
 
@@ -25,12 +25,12 @@ class Planner(Entity):
 
     @property
     def tasks(self):
-        # type: () -> EntityCollection[PlannerTask]
+        # type: () -> PlannerTaskCollection
         """Returns the plannerTasks assigned to the user."""
         return self.properties.get(
             "tasks",
-            EntityCollection(
-                self.context, PlannerTask, ResourcePath("tasks", self.resource_path)
+            PlannerTaskCollection(
+                self.context, ResourcePath("tasks", self.resource_path)
             ),
         )
 

office365/planner/plans/container.py

@@ -9,3 +9,15 @@ class PlannerPlanContainer(ClientValue):
     the contained plans are also deleted. The properties of the plannerPlanContainer cannot be changed after the plan
     is created.
     """
+
+    def __init__(self, container_id=None, type_=None, url=None):
+        """
+        :param str container_id: The identifier of the resource that contains the plan
+        :param str type_: The type of the resource that contains the plan. For supported types, see the previous
+            table. Possible values are: group, unknownFutureValue, roster. Use the Prefer: include-unknown-enum-members
+            request header to get the following value in this evolvable enum: roster.
+        :param str url: 	The full canonical URL of the container.
+        """
+        self.containerId = container_id
+        self.type = type_
+        self.url = url

office365/planner/plans/details.py

@@ -1,4 +1,6 @@
 from office365.entity import Entity
+from office365.planner.category_descriptions import PlannerCategoryDescriptions
+from office365.planner.user_ids import PlannerUserIds
 
 
 class PlannerPlanDetails(Entity):
@@ -6,3 +8,32 @@ class PlannerPlanDetails(Entity):
     The plannerPlanDetails resource represents the additional information about a plan.
     Each plan object has a details object.
     """
+
+    @property
+    def category_descriptions(self):
+        # type: () -> PlannerCategoryDescriptions
+        """
+        An object that specifies the descriptions of the 25 categories that can be associated with tasks in the plan.
+        """
+        return self.properties.get(
+            "categoryDescriptions", PlannerCategoryDescriptions()
+        )
+
+    @property
+    def shared_with(self):
+        # type: () -> PlannerUserIds
+        """
+        Set of user IDs that this plan is shared with. If you're using Microsoft 365 groups, use the Groups
+        API to manage group membership to share the group's plan. You can also add existing members of the group to
+        this collection, although it isn't required for them to access the plan owned by the group.
+        """
+        return self.properties.get("sharedWith", PlannerUserIds())
+
+    def get_property(self, name, default_value=None):
+        if default_value is None:
+            property_mapping = {
+                "categoryDescriptions": self.category_descriptions,
+                "sharedWith": self.shared_with,
+            }
+            default_value = property_mapping.get(name, None)
+        return super(PlannerPlanDetails, self).get_property(name, default_value)

office365/planner/tasks/collection.py

@@ -0,0 +1,37 @@
+from office365.entity_collection import EntityCollection
+from office365.planner.plans.plan import PlannerPlan
+from office365.planner.tasks.task import PlannerTask
+from office365.runtime.queries.create_entity import CreateEntityQuery
+
+
+class PlannerTaskCollection(EntityCollection[PlannerTask]):
+    def __init__(self, context, resource_path=None):
+        super(PlannerTaskCollection, self).__init__(context, PlannerTask, resource_path)
+
+    def add(self, title, plan, bucket=None):
+        """
+        Create a new plannerTask.
+
+        :param str title: Task title
+        :param str|PlannerPlan plan: Plan identifier or Plan object
+        :param str|PlannerBucket bucket: Bucket identifier or Plan object
+        """
+        return_type = PlannerTask(self.context)
+        self.add_child(return_type)
+
+        def _add(plan_id):
+            # type: (str) -> None
+            payload = {"title": title, "planId": plan_id, "bucketId": bucket}
+            qry = CreateEntityQuery(self, payload, return_type)
+            self.context.add_query(qry)
+
+        if isinstance(plan, PlannerPlan):
+
+            def _parent_loaded():
+                _add(plan.id)
+
+            plan.ensure_property("id", _parent_loaded)
+        else:
+            _add(plan)
+
+        return return_type

office365/planner/tasks/task.py

@@ -1,3 +1,6 @@
+from datetime import datetime
+
+from office365.directory.permissions.identity_set import IdentitySet
 from office365.entity import Entity
 from office365.planner.tasks.task_details import PlannerTaskDetails
 from office365.runtime.paths.resource_path import ResourcePath
@@ -11,6 +14,18 @@ class PlannerTask(Entity):
     See overview for more information regarding relationships between group, plan and task.
     """
 
+    @property
+    def created_by(self):
+        """Identity of the user that created the task."""
+        return self.properties.get("createdBy", IdentitySet())
+
+    @property
+    def created_datetime(self):
+        """
+        Date and time at which the task is created.
+        """
+        return self.properties.get("createdDateTime", datetime.min)
+
     @property
     def title(self):
         """Required. Title of the task."""
@@ -25,3 +40,12 @@ class PlannerTask(Entity):
                 self.context, ResourcePath("details", self.resource_path)
             ),
         )
+
+    def get_property(self, name, default_value=None):
+        if default_value is None:
+            property_mapping = {
+                "createdBy": self.created_by,
+                "createdDateTime": self.created_datetime,
+            }
+            default_value = property_mapping.get(name, None)
+        return super(PlannerTask, self).get_property(name, default_value)

office365/planner/tasks/task_details.py

@@ -1,4 +1,8 @@
+from typing import Optional
+
 from office365.entity import Entity
+from office365.planner.external_references import PlannerExternalReferences
+from office365.planner.tasks.check_list_items import PlannerChecklistItems
 
 
 class PlannerTaskDetails(Entity):
@@ -7,4 +11,33 @@ class PlannerTaskDetails(Entity):
     Each task object has a details object.
     """
 
-    pass
+    @property
+    def checklist(self):
+        # type: () -> PlannerChecklistItems
+        """
+        The collection of checklist items on the task.
+        """
+        return self.properties.get("checklist", PlannerChecklistItems())
+
+    @property
+    def description(self):
+        # type: () -> Optional[str]
+        """Description of the task."""
+        return self.properties.get("description", None)
+
+    @property
+    def preview_type(self):
+        # type: () -> Optional[str]
+        """This sets the type of preview that shows up on the task.
+        The possible values are: automatic, noPreview, checklist, description, reference.
+        When set to automatic the displayed preview is chosen by the app viewing the task.
+        """
+        return self.properties.get("previewType", None)
+
+    @property
+    def references(self):
+        # type: () -> PlannerExternalReferences
+        """
+        The collection of references on the task.
+        """
+        return self.properties.get("references", PlannerExternalReferences())

office365/planner/user_ids.py

@@ -0,0 +1,8 @@
+from office365.runtime.client_value import ClientValue
+
+
+class PlannerUserIds(ClientValue):
+    """The plannerUserIds resource represents the list of users IDs that a plan is shared with, and is an Open Type.
+    If you're using Microsoft 365 groups, use the Groups API to manage group membership to share the group's plan.
+    You can also add existing members of the group to this collection though it isn't required for them to access
+    the plan owned by the group."""

office365/reports/internal/queries/create_report_query.py

@@ -1,20 +1,29 @@
+from typing import TYPE_CHECKING
+
 from office365.reports.report import Report
 from office365.runtime.client_result import ClientResult
 from office365.runtime.queries.function import FunctionQuery
 
+if TYPE_CHECKING:
+    from office365.reports.root import ReportRoot
+
 
-def create_report_query(report_root, report_name, period=None):
+def create_report_query(report_root, report_name, period=None, return_stream=False):
     """
     Construct Report query
 
-    :param office365.reports.root.ReportRoot report_root: Report container
+    :param ReportRoot report_root: Report container
     :param str report_name: Report name
     :param str period: Specifies the length of time over which the report is aggregated.
         The supported values for {period_value} are: D7, D30, D90, and D180. These values follow the format
         Dn where n represents the number of days over which the report is aggregated. Required.
+    :param bool return_stream: If true, return a stream of report data.
     """
     params = {
         "period": period,
     }
-    return_type = ClientResult(report_root.context, Report())
+    if return_stream:
+        return_type = ClientResult(report_root.context, bytes())
+    else:
+        return_type = ClientResult(report_root.context, Report())
     return FunctionQuery(report_root, report_name, params, return_type)