Office365-REST-Python-Client 2.5.13__py3-none-any.whl → 2.5.14__py3-none-any.whl

office365/onedrive/driveitems/retention_label.py

@@ -1,7 +1,11 @@
+from datetime import datetime
 from typing import Optional
 
 from office365.directory.permissions.identity_set import IdentitySet
 from office365.entity import Entity
+from office365.onedrive.driveitems.retention_label_settings import (
+    RetentionLabelSettings,
+)
 
 
 class ItemRetentionLabel(Entity):
@@ -23,3 +27,32 @@ class ItemRetentionLabel(Entity):
         # type: () -> Optional[IdentitySet]
         """Identity of the user who applied the label. Read-only."""
         return self.properties.get("labelAppliedBy", IdentitySet())
+
+    @property
+    def label_applied_datetime(self):
+        # type: () -> Optional[datetime]
+        """The date and time when the label was applied on the item.
+        The timestamp type represents date and time information using ISO 8601 format and is always in UTC.
+        """
+        return self.properties.get("labelAppliedDateTime", datetime.min)
+
+    @property
+    def name(self):
+        # type: () -> Optional[str]
+        """The retention label on the document. Read-write."""
+        return self.properties.get("name", None)
+
+    @property
+    def retention_settings(self):
+        # type: () -> RetentionLabelSettings
+        """The retention settings enforced on the item. Read-write."""
+        return self.properties.get("retentionSettings", RetentionLabelSettings())
+
+    def get_property(self, name, default_value=None):
+        if default_value is None:
+            property_mapping = {
+                "labelAppliedBy": self.label_applied_by,
+                "retentionSettings": self.retention_settings,
+            }
+            default_value = property_mapping.get(name, None)
+        return super(ItemRetentionLabel, self).get_property(name, default_value)

office365/onedrive/driveitems/retention_label_settings.py

@@ -0,0 +1,7 @@
+from office365.runtime.client_value import ClientValue
+
+
+class RetentionLabelSettings(ClientValue):
+    """
+    Groups all the compliance retention restrictions on the item into a single structure.
+    """

office365/onedrive/sitepages/base.py

@@ -7,6 +7,9 @@ from office365.onedrive.driveitems.publication_facet import PublicationFacet
 class BaseSitePage(BaseItem):
     """An abstract type that represents a page in the site page library."""
 
+    def __repr__(self):
+        return self.name or self.entity_type_name
+
     @property
     def publishing_state(self):
         # type: () -> Optional[str]

office365/onedrive/sitepages/collection.py

@@ -10,10 +10,22 @@ class SitePageCollection(EntityCollection[SitePage]):
     def __init__(self, context, resource_path=None):
         super(SitePageCollection, self).__init__(context, SitePage, resource_path)
 
+    def get(self):
+        def _construct_request(request):
+            # type: (RequestOptions) -> None
+            # request.url += "/microsoft.graph.sitePage"
+            pass
+
+        return super(SitePageCollection, self).get().before_execute(_construct_request)
+
+    def get_by_name(self, name):
+        return self.single("name eq '{0}'".format(name))
+
     def add(self, title):
         """
         Create a new sitePage in the site pages list in a site.
 
+        :param str title:
         """
 
         def _construct_request(request):

office365/onedrive/sitepages/site_page.py

@@ -15,23 +15,23 @@ class SitePage(BaseSitePage):
     webParts."""
 
     def get_web_parts_by_position(
-        self, webPartIndex, horizontalSectionId, isInVerticalSection, columnId
+        self, web_part_index, horizontal_section_id, is_in_vertical_section, column_id
     ):
         """
         Get a collection of webPart by providing webPartPosition information.
 
-        :param float webPartIndex: Index of the current WebPart. Represents the order of WebPart in this column or
+        :param float web_part_index: Index of the current WebPart. Represents the order of WebPart in this column or
              section. Only works if either columnId or isInVerticalSection is provided.
-        :param float horizontalSectionId: Indicate the horizontal section where the WebPart located in.
-        :param bool isInVerticalSection: Indicate whether the WebPart located in the vertical section.
-        :param float columnId: Indicate the identifier of the column where the WebPart located in. Only works
+        :param float horizontal_section_id: Indicate the horizontal section where the WebPart located in.
+        :param bool is_in_vertical_section: Indicate whether the WebPart located in the vertical section.
+        :param float column_id: Indicate the identifier of the column where the WebPart located in. Only works
              if horizontalSectionId is provided.
         """
         params = {
-            "webPartIndex": webPartIndex,
-            "horizontalSectionId": horizontalSectionId,
-            "isInverticalSection": isInVerticalSection,
-            "columnId": columnId,
+            "webPartIndex": web_part_index,
+            "horizontalSectionId": horizontal_section_id,
+            "isInverticalSection": is_in_vertical_section,
+            "columnId": column_id,
         }
         return_type = EntityCollection(
             self.context, WebPart, ResourcePath("webParts", self.resource_path)

office365/onedrive/sites/archival_details.py

@@ -0,0 +1,5 @@
+from office365.runtime.client_value import ClientValue
+
+
+class SiteArchivalDetails(ClientValue):
+    """Represents the archival details of a siteCollection."""

office365/onedrive/sites/site_collection.py

@@ -1,17 +1,26 @@
+from office365.onedrive.sites.archival_details import SiteArchivalDetails
 from office365.runtime.client_value import ClientValue
 
 
 class SiteCollection(ClientValue):
     """The siteCollection resource provides more information about a site collection."""
 
-    def __init__(self, root=None, hostname=None, data_location_code=None):
+    def __init__(
+        self,
+        root=None,
+        hostname=None,
+        data_location_code=None,
+        archival_details=SiteArchivalDetails(),
+    ):
         """
 
         :param office365.onedrive.root.Root root: The hostname for the site collection.
         :param str hostname: The hostname for the site collection.
         :param str data_location_code: The geographic region code for where this site collection resides
+        :param str archival_details: Represents the archival details of a siteCollection.
         """
         super(SiteCollection, self).__init__()
         self.root = root
         self.hostname = hostname
         self.dataLocationCode = data_location_code
+        self.archivalDetails = archival_details

office365/onedrive/workbooks/functions/functions.py

@@ -45,6 +45,29 @@ class WorkbookFunctions(Entity):
         self.context.add_query(qry)
         return return_type
 
+    def accr_int_m(self, issue, settlement, rate, par, basis):
+        """
+        Returns the accrued interest for a security that pays periodic interest.
+
+        :param any issue: The real number of which you want the absolute value.
+        :param any settlement: The security's settlement date. The security settlement date is the date after
+            the issue date when the security is traded to the buyer.
+        :param any rate: The security's annual coupon rate.
+        :param any par: The security's par value. If you omit par, ACCRINT uses $1,000.
+        :param any basis:
+        """
+        return_type = WorkbookFunctionResult(self.context)
+        payload = {
+            "issue": issue,
+            "settlement": settlement,
+            "rate": rate,
+            "par": par,
+            "basis": basis,
+        }
+        qry = ServiceOperationQuery(self, "accrIntM", None, payload, None, return_type)
+        self.context.add_query(qry)
+        return return_type
+
     def days(self, start_date, end_date):
         """Returns the number of days between two dates.
 

office365/planner/tasks/check_list_item.py

@@ -7,4 +7,8 @@ class PlannerChecklistItem(ClientValue):
     The checklist on a task is represented by the checklistItems object.
     """
 
-    pass
+    def __init__(self, title=None):
+        """
+        :param str|None title: The title of the checklist.
+        """
+        self.title = title

office365/runtime/client_object.py

@@ -30,7 +30,7 @@ class ClientObject(Generic[T]):
         # type: (ClientRuntimeContext, Optional[ResourcePath], Optional[ClientObjectCollection]) -> None
         """Base client object which define named properties and relationships of an entity."""
         self._properties = {}
-        self._ser_property_names = []
+        self._properties_to_persist = []
         self._query_options = QueryOptions()
         self._parent_collection = parent_collection
         self._context = context
@@ -43,9 +43,9 @@ class ClientObject(Generic[T]):
         self._properties = {
             k: v
             for k, v in self._properties.items()
-            if k not in self._ser_property_names
+            if k not in self._properties_to_persist
         }
-        self._ser_property_names = []
+        self._properties_to_persist = []
         self._query_options = QueryOptions()
         return self
 
@@ -139,8 +139,8 @@ class ClientObject(Generic[T]):
         Marks a property as a serializable
         :param str name: A property name
         """
-        if name not in self._ser_property_names:
-            self._ser_property_names.append(name)
+        if name not in self._properties_to_persist:
+            self._properties_to_persist.append(name)
         return self
 
     def get_property(self, name, default_value=None):
@@ -155,7 +155,7 @@ class ClientObject(Generic[T]):
         # type: (str|int, P_T, bool) -> Self
         """Sets property value"""
         if persist_changes:
-            self._ser_property_names.append(name)
+            self._properties_to_persist.append(name)
 
         typed_value = self.get_property(name)
         if isinstance(typed_value, (ClientObject, ClientValue)):
@@ -242,6 +242,14 @@ class ClientObject(Generic[T]):
     def properties(self):
         return self._properties
 
+    @property
+    def persistable_properties(self):
+        return {
+            k: self.get_property(k)
+            for k in self._properties_to_persist
+            if k in self._properties
+        }
+
     @property
     def parent_collection(self):
         """Parent collection"""
@@ -254,7 +262,7 @@ class ClientObject(Generic[T]):
             ser_prop_names = [n for n in self._properties.keys()]
             include_control_info = False
         else:
-            ser_prop_names = [n for n in self._ser_property_names]
+            ser_prop_names = [n for n in self._properties_to_persist]
             include_control_info = (
                 self.entity_type_name is not None
                 and json_format.include_control_information

office365/runtime/client_object_collection.py

@@ -8,6 +8,7 @@ from office365.runtime.http.request_options import RequestOptions
 from office365.runtime.odata.json_format import ODataJsonFormat
 from office365.runtime.paths.resource_path import ResourcePath
 from office365.runtime.types.event_handler import EventHandler
+from office365.runtime.types.exceptions import NotFoundException
 
 T = TypeVar("T")
 
@@ -213,8 +214,7 @@ class ClientObjectCollection(ClientObject, Generic[T]):
         def _after_loaded(col):
             # type: (ClientObjectCollection) -> None
             if len(col) == 0:
-                message = "Not found for filter: {0}".format(expression)
-                raise ValueError(message)
+                raise NotFoundException(return_type, expression)
             elif len(col) > 1:
                 message = "Ambiguous match found for filter: {0}".format(expression)
                 raise ValueError(message)

office365/runtime/client_result.py

@@ -40,6 +40,8 @@ class ClientResult(Generic[T]):
 
         if isinstance(self._value, ClientValue):
             self._value.set_property(key, value, persist_changes)
+        elif isinstance(self._value, dict):
+            self._value[key] = value
         else:
             self._value = value
         return self

office365/runtime/client_value.py

@@ -15,7 +15,7 @@ class ClientValue(object):
     """
 
     def set_property(self, k, v, persist_changes=True):
-        # type: (str, Any, bool) -> Self
+        # type: (str|int, Any, bool) -> Self
         prop_type = getattr(self, k, None)
         if isinstance(prop_type, ClientValue) and v is not None:
             if isinstance(v, list):

office365/runtime/csom/request.py

@@ -0,0 +1,11 @@
+from office365.runtime.client_request import ClientRequest
+
+
+class CsomRequest(ClientRequest):
+    """"""
+
+    def process_response(self, response, query):
+        pass
+
+    def build_request(self, query):
+        pass

office365/runtime/types/exceptions.py

@@ -0,0 +1,18 @@
+from office365.runtime.client_object import ClientObject
+
+
+class NotFoundException(Exception):
+    def __init__(self, entity=None, query=None):
+        # type: (ClientObject, str) -> None
+        self.entity = entity
+        self.query = query
+
+    def __str__(self):
+        if self.entity is None:
+            message = "Entity not found"
+        else:
+            message = "{0} not found".format(self.entity.entity_type_name)
+
+        if self.query is not None:
+            message = "{0} for query: {1}".format(message, self.query)
+        return message

office365/search/acronym.py

@@ -0,0 +1,10 @@
+from office365.search.answer import SearchAnswer
+
+
+class Acronym(SearchAnswer):
+    """Represents an acronym that is an administrative answer in Microsoft Search results to define common
+    acronyms in an organization."""
+
+    @property
+    def entity_type_name(self):
+        return "microsoft.graph.search.acronym"

office365/search/aggregation_option.py

@@ -0,0 +1,6 @@
+from office365.runtime.client_value import ClientValue
+
+
+class AggregationOption(ClientValue):
+    """Specifies which aggregations should be returned alongside the search results.
+    The maximum returned value is 100 buckets."""

office365/search/answer.py

@@ -0,0 +1,9 @@
+from office365.entity import Entity
+
+
+class SearchAnswer(Entity):
+    """Represents the base type for other search answers."""
+
+    @property
+    def entity_type_name(self):
+        return "microsoft.graph.search.searchAnswer"

office365/search/entity.py

@@ -1,10 +1,15 @@
 from typing import List, Optional
 
 from office365.entity import Entity
+from office365.entity_collection import EntityCollection
 from office365.runtime.client_result import ClientResult
 from office365.runtime.client_value_collection import ClientValueCollection
+from office365.runtime.paths.resource_path import ResourcePath
+from office365.runtime.paths.v4.entity import EntityPath
 from office365.runtime.queries.service_operation import ServiceOperationQuery
+from office365.search.acronym import Acronym
 from office365.search.entity_type import EntityType
+from office365.search.hit import SearchHit
 from office365.search.query import SearchQuery
 from office365.search.request import SearchRequest
 from office365.search.response import SearchResponse
@@ -16,27 +21,42 @@ class SearchEntity(Entity):
     in Graph, but serves as an anchor to the query action.
     """
 
-    def query(self, query_string, entity_types=None):
-        # type: (str, Optional[List[str]]) -> ClientResult[ClientValueCollection[SearchResponse]]
+    def query(
+        self,
+        query_string,
+        entity_types=None,
+        page_from=None,
+        size=None,
+        enable_top_results=None,
+    ):
+        # type: (str, Optional[List[str]], Optional[int], Optional[int], Optional[bool]) -> ClientResult[ClientValueCollection[SearchResponse]]
         """
         Runs the query specified in the request body. Search results are provided in the response.
 
         :param str query_string: Contains the query terms.
         :param list[str] entity_types: One or more types of resources expected in the response.
             Possible values are: list, site, listItem, message, event, drive, driveItem, externalItem.
+        :param int page_from: Specifies the offset for the search results. Offset 0 returns the very first result.
+        :param int size: The size of the page to be retrieved. The maximum value is 500. Optional.
+        :param bool enable_top_results: This triggers hybrid sort for messages
         """
         search_request = SearchRequest(
-            query=SearchQuery(query_string), entity_types=entity_types
+            query=SearchQuery(query_string),
+            entity_types=entity_types,
+            page_from=page_from,
+            size=size,
+            enable_top_results=enable_top_results,
         )
-        payload = {"requests": ClientValueCollection(SearchRequest, [search_request])}
-        return_type = ClientResult(self.context, ClientValueCollection(SearchResponse))
-        qry = ServiceOperationQuery(self, "query", None, payload, None, return_type)
 
         def _patch_hit(search_hit):
-            pass
-            # resource = Entity(self.context)
-            # self.context.pending_request().map_json(search_hit.resource, resource)
-            # search_hit.set_property("resource", resource)
+            # type: (SearchHit) -> None
+            resource_type_name = search_hit.get_property("resource").get(
+                "@odata.type", None
+            )
+            resource_type = EntityType.resolve(resource_type_name)
+            resource = resource_type(self.context, EntityPath())
+            self.context.pending_request().map_json(search_hit.resource, resource)
+            search_hit.set_property("resource", resource)
 
         def _process_response(result):
             # type: (ClientResult[ClientValueCollection[SearchResponse]]) -> None
@@ -44,14 +64,28 @@ class SearchEntity(Entity):
                 for hcs in item.hitsContainers:
                     [_patch_hit(hit) for hit in hcs.hits]
 
+        payload = {"requests": ClientValueCollection(SearchRequest, [search_request])}
+        return_type = ClientResult(self.context, ClientValueCollection(SearchResponse))
+        qry = ServiceOperationQuery(self, "query", None, payload, None, return_type)
         self.context.add_query(qry).after_query_execute(_process_response)
         return return_type
 
-    def query_messages(self, query_string):
+    def query_messages(
+        self, query_string, page_from=None, size=None, enable_top_results=None
+    ):
         """Searches Outlook messages. Alias to query method
         :param str query_string: Contains the query terms.
+        :param int page_from: Specifies the offset for the search results. Offset 0 returns the very first result.
+        :param int size: The size of the page to be retrieved. The maximum value is 500. Optional.
+        :param bool enable_top_results: This triggers hybrid sort for messages
         """
-        return self.query(query_string, entity_types=[EntityType.message])
+        return self.query(
+            query_string,
+            entity_types=[EntityType.message],
+            page_from=page_from,
+            size=size,
+            enable_top_results=enable_top_results,
+        )
 
     def query_events(self, query_string):
         """Searches Outlook calendar events. Alias to query method
@@ -59,8 +93,27 @@ class SearchEntity(Entity):
         """
         return self.query(query_string, entity_types=[EntityType.event])
 
-    def query_drive_items(self, query_string):
+    def query_drive_items(self, query_string, page_from=None, size=None):
         """Searches OneDrive items. Alias to query method
         :param str query_string: Contains the query terms.
+        :param int page_from: Specifies the offset for the search results. Offset 0 returns the very first result.
+        :param int size: The size of the page to be retrieved. The maximum value is 500.
         """
-        return self.query(query_string, entity_types=[EntityType.driveItem])
+        return self.query(
+            query_string,
+            entity_types=[EntityType.driveItem],
+            page_from=page_from,
+            size=size,
+        )
+
+    @property
+    def acronyms(self):
+        """Administrative answer in Microsoft Search results to define common acronyms in an organization."""
+        return self.properties.get(
+            "acronyms",
+            EntityCollection(
+                self.context,
+                Acronym,
+                ResourcePath("acronyms", self.resource_path),
+            ),
+        )

office365/search/entity_type.py

@@ -1,9 +1,37 @@
+from typing import Type
+
+from office365.onedrive.driveitems.driveItem import DriveItem
+from office365.onedrive.drives.drive import Drive
+from office365.onedrive.listitems.list_item import ListItem
+from office365.onedrive.lists.list import List
+from office365.onedrive.sites.site import Site
+from office365.outlook.calendar.events.event import Event
+from office365.outlook.mail.messages.message import Message
+
+
 class EntityType:
     """Search resource type"""
 
+    _types = {
+        "event": Event,
+        "list": List,
+        "site": Site,
+        "listItem": ListItem,
+        "message": Message,
+        "drive": Drive,
+        "driveItem": DriveItem,
+        # "externalItem": ExternalItem
+    }
+
     def __init__(self):
         pass
 
+    @staticmethod
+    def resolve(name):
+        # type: (str) -> Type[Event | List | Site | ListItem | Message | Drive | DriveItem]
+        class_name = name.split(".")[-1]
+        return EntityType._types.get(class_name, None)
+
     event = "event"
 
     list = "list"

office365/search/request.py

@@ -1,6 +1,10 @@
+from typing import Dict, Optional
+
 from office365.runtime.client_value import ClientValue
 from office365.runtime.client_value_collection import ClientValueCollection
+from office365.runtime.odata.json_format import ODataJsonFormat
 from office365.runtime.types.collections import StringCollection
+from office365.search.aggregation_option import AggregationOption
 from office365.search.sharepoint_onedrive_options import SharePointOneDriveOptions
 from office365.search.sort_property import SortProperty
 
@@ -11,15 +15,29 @@ class SearchRequest(ClientValue):
     def __init__(
         self,
         query,
+        aggregation_filters=None,
+        aggregations=None,
+        enable_top_results=None,
+        size=None,
+        region=None,
         entity_types=None,
         fields=None,
-        search_from=None,
+        page_from=None,
         sort_properties=None,
         content_sources=None,
         sharepoint_onedrive_options=SharePointOneDriveOptions(),
     ):
         """
         :param office365.search.query.SearchQuery query: Contains the query terms.
+        :param list[str] aggregation_filters: Contains one or more filters to obtain search results aggregated and
+            filtered to a specific value of a field
+        :param list[str] aggregations: Specifies aggregations (also known as refiners) to be returned
+            alongside search results.
+        :param bool enable_top_results: This triggers hybrid sort for messages : the first 3 messages are
+            the most relevant. This property is only applicable to entityType=message. Optional.
+        :param int size: The size of the page to be retrieved. The maximum value is 500. Optional.
+        :param str region: The geographic location for the search. Required for searches that use application
+            permissions. For details, see Get the region value.
         :param list[str] entity_types: One or more types of resources expected in the response.
             Possible values are: list, site, listItem, message, event, drive, driveItem, externalItem.
             See known limitations for those combinations of two or more entity types that are supported in the
@@ -30,16 +48,27 @@ class SearchRequest(ClientValue):
             content that Microsoft Graph connectors bring in. The fields property can use the semantic labels
             applied to properties. For example, if a property is labeled as title, you can retrieve it using
             the following syntax: label_title.
-        :param int search_from: Specifies the offset for the search results. Offset 0 returns the very first result.
+        :param int page_from: Specifies the offset for the search results. Offset 0 returns the very first result.
         :param list[SortProperty] sort_properties: Contains the ordered collection of fields and direction to
             sort results. There can be at most 5 sort properties in the collection.
         :param list[str] content_sources: Contains the connection to be targeted.
         """
         super(SearchRequest, self).__init__()
         self.query = query
+        self.aggregationFilters = StringCollection(aggregation_filters)
+        self.aggregations = ClientValueCollection(AggregationOption, aggregations)
+        self.enableTopResults = enable_top_results
+        self.size = size
+        self.region = region
         self.entityTypes = entity_types
         self.fields = fields
-        self.search_from = search_from
+        self.page_from = page_from
         self.sortProperties = ClientValueCollection(SortProperty, sort_properties)
         self.contentSources = StringCollection(content_sources)
         self.sharePointOneDriveOptions = sharepoint_onedrive_options
+
+    def to_json(self, json_format=None):
+        # type: (Optional[ODataJsonFormat]) -> Dict
+        json_value = super(SearchRequest, self).to_json(json_format)
+        json_value["from"] = json_value.pop("page_from", None)
+        return json_value

office365/sharepoint/apps/access_requests.py

@@ -0,0 +1,5 @@
+from office365.sharepoint.entity import Entity
+
+
+class AccessRequests(Entity):
+    """ """

office365/sharepoint/apps/management/principal_info.py

@@ -0,0 +1,9 @@
+from office365.sharepoint.entity import Entity
+
+
+class SPAppPrincipalInfo(Entity):
+    """"""
+
+    @property
+    def entity_type_name(self):
+        return "Microsoft.SharePoint.AppManagement.SPAppPrincipalInfo"