Office365-REST-Python-Client 2.5.5__py3-none-any.whl → 2.5.7__py3-none-any.whl

office365/onedrive/analytics/item_activity_stat.py

@@ -65,3 +65,12 @@ class ItemActivityStat(Entity):
                 ResourcePath("activities", self.resource_path),
             ),
         )
+
+    def get_property(self, name, default_value=None):
+        if default_value is None:
+            property_mapping = {
+                "endDateTime": self.end_datetime,
+                "startDateTime": self.start_datetime,
+            }
+            default_value = property_mapping.get(name, None)
+        return super(ItemActivityStat, self).get_property(name, default_value)

office365/onedrive/analytics/item_analytics.py

@@ -19,6 +19,7 @@ class ItemAnalytics(Entity):
 
     @property
     def item_activity_stats(self):
+        # type: () -> EntityCollection[ItemActivityStat]
         return self.properties.get(
             "itemActivityStats",
             EntityCollection(

office365/onedrive/contenttypes/content_type.py

@@ -20,9 +20,7 @@ class ContentType(BaseItem):
     columns that must be present on every listItem in a list."""
 
     def is_published(self):
-        """
-        Check the publishing status of a contentType in a content type hub site.
-        """
+        """Check the publishing status of a contentType in a content type hub site."""
         return_type = ClientResult(self.context, bool())
         qry = FunctionQuery(self, "isPublished", None, return_type)
         self.context.add_query(qry)
@@ -57,9 +55,7 @@ class ContentType(BaseItem):
         return self
 
     def unpublish(self):
-        """
-        Unpublish a contentType from a content type hub site.
-        """
+        """Unpublish a contentType from a content type hub site."""
         qry = ServiceOperationQuery(self, "unpublish")
         self.context.add_query(qry)
         return self
@@ -75,9 +71,7 @@ class ContentType(BaseItem):
 
     @property
     def document_set(self):
-        """
-        Document Set metadata.
-        """
+        """Document Set metadata."""
         return self.properties.get("documentSet", DocumentSet())
 
     @property
@@ -115,9 +109,7 @@ class ContentType(BaseItem):
     @property
     def read_only(self):
         # type: () -> Optional[bool]
-        """
-        If true, the content type cannot be modified unless this value is first set to false.
-        """
+        """If true, the content type cannot be modified unless this value is first set to false."""
         return self.properties.get("readOnly", None)
 
     @property

office365/onedrive/driveitems/driveItem.py

@@ -2,6 +2,8 @@ from __future__ import annotations
 
 import os
 from datetime import datetime
+from functools import partial
+from os.path import isfile, join
 from typing import IO, AnyStr, Callable, Optional, TypeVar
 
 import requests
@@ -209,7 +211,8 @@ class DriveItem(BaseItem):
         :param int chunk_size: chunk size
         """
 
-        def _start_upload():
+        def _start_upload(result):
+            # type: (ClientResult[UploadSession]) -> None
             with open(source_path, "rb") as local_file:
                 session_request = UploadSessionRequest(
                     local_file, chunk_size, chunk_uploaded
@@ -271,6 +274,30 @@ class DriveItem(BaseItem):
             name = os.path.basename(path_or_file)
             return self.upload(name, content)
 
+    def upload_folder(self, path, file_uploaded=None):
+        # type: (str, Callable[["DriveItem"], None]) -> "DriveItem"
+
+        def _after_file_upload(return_type):
+            # type: ("DriveItem") -> None
+            if callable(file_uploaded):
+                file_uploaded(return_type)
+
+        def _upload_folder(source_path, target_folder):
+            # type: (str, "DriveItem") -> None
+            for name in os.listdir(source_path):
+                cur_path = join(source_path, name)
+                if isfile(cur_path):
+                    with open(cur_path, "rb") as f:
+                        target_folder.upload_file(f).after_execute(_after_file_upload)
+                else:
+                    target_folder.create_folder(name).after_execute(
+                        partial(_upload_folder, cur_path)
+                    )
+
+        """Uploads a folder"""
+        _upload_folder(path, self)
+        return self
+
     def get_content(self, format_name=None):
         # type: (Optional[str]) -> ClientResult[AnyStr]
         """
@@ -301,6 +328,52 @@ class DriveItem(BaseItem):
         self.get_content().after_execute(_save_content)
         return self
 
+    def download_folder(
+        self, download_file, after_file_downloaded=None, recursive=True
+    ):
+        # type: (IO, Callable[[File], None], bool) -> "DriveItem"
+        """
+        Download the folder content
+        """
+        import zipfile
+
+        def _after_file_downloaded(drive_item, base_path, result):
+            # type: ("DriveItem", str, ClientResult[AnyStr]) -> None
+            with zipfile.ZipFile(download_file.name, "a", zipfile.ZIP_DEFLATED) as zf:
+                zip_path = (
+                    "/".join([base_path, drive_item.name])
+                    if base_path is not None
+                    else drive_item.name
+                )
+                zf.writestr(zip_path, result.value)
+                if callable(after_file_downloaded):
+                    after_file_downloaded(drive_item)
+
+        def _after_folder_downloaded(parent_item, base_path=None):
+            # type: ("DriveItem", str) -> None
+            for drive_item in parent_item.children:
+                if drive_item.is_file:
+                    drive_item.get_content().after_execute(
+                        partial(_after_file_downloaded, drive_item, base_path)
+                    )
+                else:
+                    if recursive:
+                        if base_path is None:
+                            next_base_path = str(drive_item.name)
+                        else:
+                            next_base_path = "/".join([base_path, drive_item.name])
+                        _download_folder(drive_item, next_base_path)
+
+        def _download_folder(drive_item, prev_result=None):
+            # type: ("DriveItem", str) -> None
+            drive_item.ensure_properties(
+                ["children", "name"],
+                partial(_after_folder_downloaded, drive_item, prev_result),
+            )
+
+        _download_folder(self)
+        return self
+
     def download_session(
         self, file_object, chunk_downloaded=None, chunk_size=1024 * 1024
     ):
@@ -599,9 +672,7 @@ class DriveItem(BaseItem):
     @property
     def audio(self):
         # type: () -> Audio
-        """
-        Audio metadata, if the item is an audio file. Read-only.
-        """
+        """Audio metadata, if the item is an audio file. Read-only."""
         return self.properties.get("audio", Audio())
 
     @property
@@ -615,9 +686,7 @@ class DriveItem(BaseItem):
     @property
     def photo(self):
         # type: () -> Photo
-        """
-        Photo metadata, if the item is a photo. Read-only.
-        """
+        """Photo metadata, if the item is a photo. Read-only."""
         return self.properties.get("photo", Photo())
 
     @property

office365/onedrive/files/hashes.py

@@ -0,0 +1,5 @@
+from office365.runtime.client_value import ClientValue
+
+
+class Hashes(ClientValue):
+    """The Hashes resource groups available hashes into a single structure for an item."""

office365/onedrive/lists/collection.py

@@ -1,6 +1,6 @@
 from office365.entity_collection import EntityCollection
 from office365.onedrive.lists.list import List
-from office365.runtime.paths.item import ItemPath
+from office365.runtime.paths.v4.entity import EntityPath
 from office365.runtime.queries.create_entity import CreateEntityQuery
 
 
@@ -17,7 +17,7 @@ class ListCollection(EntityCollection[List]):
         :param str display_name: The displayable title of the list.
         :param str list_template: The base list template used in creating the list
         """
-        return_type = List(self.context, ItemPath(self.resource_path))
+        return_type = List(self.context, EntityPath(None, self.resource_path))
         self.add_child(return_type)
         payload = {
             "displayName": display_name,

office365/onedrive/lists/list.py

@@ -17,7 +17,7 @@ class List(BaseItem):
     including template and field definitions."""
 
     def __str__(self):
-        return self.display_name
+        return self.display_name or self.entity_type_name
 
     @property
     def display_name(self):

office365/onedrive/operations/long_running.py

@@ -1,3 +1,5 @@
+from typing import Optional
+
 from office365.entity import Entity
 
 
@@ -6,14 +8,12 @@ class LongRunningOperation(Entity):
 
     @property
     def resource_location(self):
-        """URI of the resource that the operation is performed on.
-        :rtype: str or None
-        """
+        # type: () -> Optional[str]
+        """URI of the resource that the operation is performed on."""
         return self.properties.get("resourceLocation", None)
 
     @property
     def status_detail(self):
-        """Details about the status of the operation.
-        :rtype: str or None
-        """
+        # type: () -> Optional[str]
+        """Details about the status of the operation."""
         return self.properties.get("statusDetail", None)

office365/onedrive/operations/rich_long_running.py

@@ -1,3 +1,5 @@
+from typing import Optional
+
 from office365.onedrive.operations.long_running import LongRunningOperation
 
 
@@ -6,7 +8,6 @@ class RichLongRunningOperation(LongRunningOperation):
 
     @property
     def resource_id(self):
-        """The unique identifier for the result.
-        :rtype: str or None
-        """
+        # type: () -> Optional[str]
+        """The unique identifier for the result."""
         return self.properties.get("resourceId", None)

office365/onedrive/permissions/collection.py

@@ -69,19 +69,6 @@ class PermissionCollection(EntityCollection[Permission]):
         identity.ensure_properties(["displayName"], _add)
         return return_type
 
-    def delete(self, roles, identity):
-        # type: (list[str], Application|User|Group|Device) -> Permission
-        """Deletes the permission."""
-
-        def _delete(col):
-            pass
-
-        def _identity_loaded():
-            self.get_all(page_loaded=_delete)
-
-        identity.ensure_property("id", _identity_loaded)
-        return self
-
     def delete_all(self):
         """Remove all access to resource"""
 
@@ -90,5 +77,5 @@ class PermissionCollection(EntityCollection[Permission]):
             for permission in return_type:
                 permission.delete_object()
 
-        self.context.load(self, after_loaded=_after_loaded)
+        self.get().after_execute(_after_loaded)
         return self

office365/onedrive/sharepoint_settings.py

@@ -1,3 +1,5 @@
+from typing import Optional
+
 from office365.entity import Entity
 from office365.runtime.types.collections import StringCollection
 
@@ -26,26 +28,24 @@ class SharepointSettings(Entity):
 
     @property
     def site_creation_default_managed_path(self):
+        # type: () -> Optional[str]
         """
         The value of the team site managed path. This is the path under which new team sites will be created.
-        :rtype: str
         """
         return self.properties.get("siteCreationDefaultManagedPath", None)
 
     @property
     def site_creation_default_storage_limit_in_mb(self):
-        """
-        The default storage quota for a new site upon creation. Measured in megabytes (MB).
-        :rtype: int
-        """
+        # type: () -> Optional[int]
+        """The default storage quota for a new site upon creation. Measured in megabytes (MB)."""
         return self.properties.get("siteCreationDefaultStorageLimitInMB", None)
 
     @property
     def tenant_default_timezone(self):
+        # type: () -> Optional[str]
         """
         The default timezone of a tenant for newly created sites. For a list of possible values,
         see SPRegionalSettings.TimeZones property.
-        :rtype: str
         """
         return self.properties.get("tenantDefaultTimezone", None)
 

office365/onedrive/sitepages/base.py

@@ -0,0 +1,29 @@
+from typing import Optional
+
+from office365.base_item import BaseItem
+from office365.onedrive.driveitems.publication_facet import PublicationFacet
+
+
+class BaseSitePage(BaseItem):
+    """An abstract type that represents a page in the site page library."""
+
+    @property
+    def publishing_state(self):
+        # type: () -> Optional[str]
+        """The publishing status and the MM.mm version of the page."""
+        return self.properties.get("publishingState", PublicationFacet())
+
+    @property
+    def page_layout(self):
+        # type: () -> Optional[str]
+        """
+        The name of the page layout of the page.
+        The possible values are: microsoftReserved, article, home, unknownFutureValue.
+        """
+        return self.properties.get("pageLayout", None)
+
+    @property
+    def title(self):
+        # type: () -> Optional[str]
+        """Title of the sitePage."""
+        return self.properties.get("title", None)

office365/onedrive/sitepages/canvas_layout.py

@@ -0,0 +1,43 @@
+from office365.entity import Entity
+from office365.entity_collection import EntityCollection
+from office365.onedrive.sitepages.horizontal_section import HorizontalSection
+from office365.onedrive.sitepages.vertical_section import VerticalSection
+from office365.runtime.paths.resource_path import ResourcePath
+
+
+class CanvasLayout(Entity):
+    """Represents the layout of the content in a given SharePoint page."""
+
+    @property
+    def horizontal_sections(self):
+        # type: () -> EntityCollection[HorizontalSection]
+        """Collection of horizontal sections on the SharePoint page.."""
+        return self.properties.get(
+            "horizontalSections",
+            EntityCollection(
+                self.context,
+                HorizontalSection,
+                ResourcePath("horizontalSections", self.resource_path),
+            ),
+        )
+
+    @property
+    def vertical_section(self):
+        # type: () -> VerticalSection
+        """Vertical section on the SharePoint page."""
+        return self.properties.get(
+            "verticalSection",
+            VerticalSection(
+                self.context,
+                ResourcePath("verticalSection", self.resource_path),
+            ),
+        )
+
+    def get_property(self, name, default_value=None):
+        if default_value is None:
+            property_mapping = {
+                "horizontalSections": self.horizontal_sections,
+                "verticalSection": self.vertical_section,
+            }
+            default_value = property_mapping.get(name, None)
+        return super(CanvasLayout, self).get_property(name, default_value)

office365/onedrive/sitepages/collection.py

@@ -0,0 +1,32 @@
+from office365.entity_collection import EntityCollection
+from office365.onedrive.sitepages.site_page import SitePage
+from office365.onedrive.sitepages.title_area import TitleArea
+from office365.runtime.http.request_options import RequestOptions
+
+
+class SitePageCollection(EntityCollection[SitePage]):
+    """Sites container"""
+
+    def __init__(self, context, resource_path=None):
+        super(SitePageCollection, self).__init__(context, SitePage, resource_path)
+
+    def add(self, title):
+        """
+        Create a new sitePage in the site pages list in a site.
+
+        """
+
+        def _construct_request(request):
+            # type: (RequestOptions) -> None
+            request.set_header("Content-Type", "application/json")
+
+        return (
+            super(SitePageCollection, self)
+            .add(
+                title=title,
+                name="{0}.aspx".format(title),
+                pageLayout="article",
+                titleArea=TitleArea(),
+            )
+            .before_execute(_construct_request)
+        )

office365/onedrive/sitepages/horizontal_section.py

@@ -0,0 +1,23 @@
+from office365.entity import Entity
+from office365.entity_collection import EntityCollection
+from office365.onedrive.sitepages.horizontal_section_column import (
+    HorizontalSectionColumn,
+)
+from office365.runtime.paths.resource_path import ResourcePath
+
+
+class HorizontalSection(Entity):
+    """Represents a horizontal section in a given SharePoint page."""
+
+    @property
+    def columns(self):
+        # type: () -> EntityCollection[HorizontalSectionColumn]
+        """The set of vertical columns in this section."""
+        return self.properties.get(
+            "columns",
+            EntityCollection(
+                self.context,
+                HorizontalSectionColumn,
+                ResourcePath("columns", self.resource_path),
+            ),
+        )

office365/onedrive/sitepages/horizontal_section_column.py

@@ -0,0 +1,27 @@
+from office365.entity import Entity
+from office365.entity_collection import EntityCollection
+from office365.onedrive.sitepages.web_part import WebPart
+from office365.runtime.paths.resource_path import ResourcePath
+
+
+class HorizontalSectionColumn(Entity):
+    """Represents a vertical column in a given horizontal section."""
+
+    @property
+    def web_parts(self):
+        # type: () -> EntityCollection[WebPart]
+        """The set of web parts in this section."""
+        return self.properties.get(
+            "webParts",
+            EntityCollection(
+                self.context, WebPart, ResourcePath("webParts", self.resource_path)
+            ),
+        )
+
+    def get_property(self, name, default_value=None):
+        if default_value is None:
+            property_mapping = {
+                "webParts": self.web_parts,
+            }
+            default_value = property_mapping.get(name, None)
+        return super(HorizontalSectionColumn, self).get_property(name, default_value)

office365/onedrive/sitepages/site_page.py

@@ -0,0 +1,116 @@
+from typing import Optional
+
+from office365.entity_collection import EntityCollection
+from office365.onedrive.sitepages.base import BaseSitePage
+from office365.onedrive.sitepages.canvas_layout import CanvasLayout
+from office365.onedrive.sitepages.title_area import TitleArea
+from office365.onedrive.sitepages.web_part import WebPart
+from office365.runtime.paths.resource_path import ResourcePath
+from office365.runtime.queries.function import FunctionQuery
+from office365.runtime.queries.service_operation import ServiceOperationQuery
+
+
+class SitePage(BaseSitePage):
+    """This resource represents a page in the sitePages list. It contains the title, layout, and a collection of
+    webParts."""
+
+    def get_web_parts_by_position(
+        self, webPartIndex, horizontalSectionId, isInVerticalSection, columnId
+    ):
+        """
+        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
+             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
+             if horizontalSectionId is provided.
+        """
+        params = {
+            "webPartIndex": webPartIndex,
+            "horizontalSectionId": horizontalSectionId,
+            "isInverticalSection": isInVerticalSection,
+            "columnId": columnId,
+        }
+        return_type = EntityCollection(
+            self.context, WebPart, ResourcePath("webParts", self.resource_path)
+        )
+        qry = FunctionQuery(self, "getWebPartsByPosition", params, return_type)
+        self.context.add_query(qry)
+        return return_type
+
+    def publish(self):
+        """
+        Publish the latest version of a sitePage resource, which makes the version of the page available to all users.
+        If the page is checked out, check in the page and publish it. If the page is checked out to the caller
+        of this API, the page is automatically checked in and then published.
+
+        If a page approval flow has been activated in the page library, the page is not published until the approval
+        flow is completed.
+        """
+        qry = ServiceOperationQuery(self, "publish")
+        self.context.add_query(qry)
+        return self
+
+    @property
+    def promotion_kind(self):
+        # type: () -> Optional[str]
+        """Indicates the promotion kind of the sitePage."""
+        return self.properties.get("promotionKind", None)
+
+    @property
+    def show_comments(self):
+        # type: () -> Optional[bool]
+        """Determines whether or not to show comments at the bottom of the page."""
+        return self.properties.get("showComments", None)
+
+    @property
+    def show_recommended_pages(self):
+        # type: () -> Optional[bool]
+        """Determines whether or not to show recommended pages at the bottom of the page."""
+        return self.properties.get("showRecommendedPages", None)
+
+    @property
+    def thumbnail_web_url(self):
+        # type: () -> Optional[str]
+        """Indicates the promotion kind of the sitePage."""
+        return self.properties.get("thumbnailWebUrl", None)
+
+    @property
+    def title_area(self):
+        # type: () -> Optional[str]
+        """Title area on the SharePoint page."""
+        return self.properties.get("titleArea", TitleArea())
+
+    @property
+    def canvas_layout(self):
+        # type: () -> CanvasLayout
+        """The default termStore under this site."""
+        return self.properties.get(
+            "canvasLayout",
+            CanvasLayout(
+                self.context, ResourcePath("canvasLayout", self.resource_path)
+            ),
+        )
+
+    @property
+    def web_parts(self):
+        # type: () -> EntityCollection[WebPart]
+        """Collection of webparts on the SharePoint page."""
+        return self.properties.get(
+            "webParts",
+            EntityCollection(
+                self.context, WebPart, ResourcePath("webParts", self.resource_path)
+            ),
+        )
+
+    def get_property(self, name, default_value=None):
+        if default_value is None:
+            property_mapping = {
+                "canvasLayout": self.canvas_layout,
+                "titleArea": self.title_area,
+                "webParts": self.web_parts,
+            }
+            default_value = property_mapping.get(name, None)
+        return super(SitePage, self).get_property(name, default_value)

office365/onedrive/sitepages/title_area.py

@@ -0,0 +1,13 @@
+from office365.runtime.client_value import ClientValue
+
+
+class TitleArea(ClientValue):
+    """Represents the title area of a given SharePoint page."""
+
+    def __init__(self, alternativeText=None, enableGradientEffect=None):
+        """
+        :param str alternativeText: Alternative text on the title area.
+        :param bool enableGradientEffect: Indicates whether the title area has a gradient effect enabled.
+        """
+        self.alternativeText = alternativeText
+        self.enableGradientEffect = enableGradientEffect

office365/onedrive/sitepages/vertical_section.py

@@ -0,0 +1,27 @@
+from office365.entity import Entity
+from office365.entity_collection import EntityCollection
+from office365.onedrive.sitepages.web_part import WebPart
+from office365.runtime.paths.resource_path import ResourcePath
+
+
+class VerticalSection(Entity):
+    """Represents the vertical section in a given SharePoint page."""
+
+    @property
+    def web_parts(self):
+        # type: () -> EntityCollection[WebPart]
+        """The set of web parts in this section."""
+        return self.properties.get(
+            "webParts",
+            EntityCollection(
+                self.context, WebPart, ResourcePath("webParts", self.resource_path)
+            ),
+        )
+
+    def get_property(self, name, default_value=None):
+        if default_value is None:
+            property_mapping = {
+                "webParts": self.web_parts,
+            }
+            default_value = property_mapping.get(name, None)
+        return super(VerticalSection, self).get_property(name, default_value)

office365/onedrive/sitepages/web_part.py

@@ -0,0 +1,5 @@
+from office365.entity import Entity
+
+
+class WebPart(Entity):
+    """Represents a specific web part instance on a SharePoint page."""