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

office365/sharepoint/fields/url.py

@@ -1,3 +1,5 @@
+from typing import Optional
+
 from office365.sharepoint.fields.field import Field
 
 
@@ -6,9 +8,6 @@ class FieldUrl(Field):
 
     @property
     def display_format(self):
-        """
-        Gets the number of decimal places to be used when displaying the field.
-
-        :rtype: int or None
-        """
+        # type: () -> Optional[int]
+        """Gets the number of decimal places to be used when displaying the field."""
         return self.properties.get("DisplayFormat", None)

office365/sharepoint/fields/user.py

@@ -1,3 +1,5 @@
+from typing import Optional
+
 from office365.sharepoint.fields.lookup import FieldLookup
 
 
@@ -6,41 +8,40 @@ class FieldUser(FieldLookup):
 
     @property
     def presence(self):
-        """Gets a value that specifies whether presence is enabled on the field.
-
-        :rtype: bool or None
-        """
+        # type: () -> Optional[bool]
+        """Gets a value that specifies whether presence is enabled on the field."""
         return self.properties.get("Presence", None)
 
     @presence.setter
     def presence(self, val):
+        # type: (bool) -> None
         """Sets a value that specifies whether presence is enabled on the field."""
         self.properties.get("Presence", val)
 
     @property
     def allow_display(self):
-        """Gets a value that specifies whether to display the name of the user in a survey list.
-
-        :rtype: bool or None
-        """
+        # type: () -> Optional[bool]
+        """Gets a value that specifies whether to display the name of the user in a survey list."""
         return self.properties.get("AllowDisplay", None)
 
     @allow_display.setter
     def allow_display(self, val):
+        # type: (bool) -> None
         """Sets a value that specifies whether to display the name of the user in a survey list."""
         self.properties.get("AllowDisplay", val)
 
     @property
     def selection_group(self):
+        # type: () -> Optional[int]
         """
         Gets a value that specifies the identifier of the SharePoint group whose members can be selected
         as values of the field.
-        :rtype: int or None
         """
         return self.properties.get("SelectionGroup", None)
 
     @selection_group.setter
     def selection_group(self, val):
+        # type: (int) -> None
         """Sets a value that specifies the identifier of the SharePoint group whose members can be selected as
         values of the field.
         """

office365/sharepoint/files/collection.py

@@ -45,7 +45,7 @@ class FileCollection(EntityCollection[File]):
     def upload_with_checksum(self, file_object, chunk_size=1024):
         # type: (IO, int) -> File
         """ """
-        h = hashlib.sha1()  # hashlib.md5()
+        h = hashlib.md5()
         file_name = os.path.basename(file_object.name)
         upload_id = str(uuid.uuid4())
 
@@ -53,9 +53,10 @@ class FileCollection(EntityCollection[File]):
             # type: (File) -> None
             content = file_object.read(chunk_size)
             h.update(content)
+
             return_type.upload_with_checksum(
                 upload_id, h.hexdigest(), content
-            ).after_execute(_upload_session)
+            )  # .after_execute(_upload_session)
 
         return self.add(file_name, None, True).after_execute(_upload_session)
 
@@ -80,37 +81,38 @@ class FileCollection(EntityCollection[File]):
         file_name = file_name if file_name else os.path.basename(file.name)
         upload_id = str(uuid.uuid4())
 
-        def _upload_session(return_type, return_file):
-            # type: (File|ClientResult, File) -> None
-            if return_file is None:
-                return_file = return_type
+        def _upload(return_type):
+            # type: (File) -> None
+
+            def _after_uploaded(result):
+                # type: (ClientResult) -> None
+                _upload(return_type)
 
             uploaded_bytes = file.tell()
             if callable(chunk_uploaded):
                 chunk_uploaded(uploaded_bytes, **kwargs)
 
+            content = file.read(chunk_size)
             if uploaded_bytes == file_size:
                 if auto_close and not file.closed:
                     file.close()
                 return
 
-            content = file.read(chunk_size)
-
             if uploaded_bytes == 0:
-                return_file.start_upload(upload_id, content).after_execute(
-                    _upload_session, return_file
+                return_type.start_upload(upload_id, content).after_execute(
+                    _after_uploaded
                 )
             elif uploaded_bytes + len(content) < file_size:
-                return_file.continue_upload(
+                return_type.continue_upload(
                     upload_id, uploaded_bytes, content
-                ).after_execute(_upload_session, return_file)
+                ).after_execute(_after_uploaded)
             else:
-                return_file.finish_upload(
+                return_type.finish_upload(
                     upload_id, uploaded_bytes, content
-                ).after_execute(_upload_session, return_file)
+                ).after_execute(_upload)
 
         if file_size > chunk_size:
-            return self.add(file_name, None, True).after_execute(_upload_session, None)
+            return self.add(file_name, None, True).after_execute(_upload)
         else:
             return self.add(file_name, file.read(), True)
 

office365/sharepoint/files/file.py

@@ -59,10 +59,7 @@ class File(AbstractFile):
     or a file in a folder."""
 
     def __repr__(self):
-        if self.server_relative_path:
-            return repr(self.server_relative_path)
-        else:
-            return self.serverRelativeUrl or self.unique_id or self.entity_type_name
+        return self.serverRelativeUrl or self.unique_id or self.entity_type_name
 
     def __str__(self):
         return self.name or self.entity_type_name
@@ -132,6 +129,19 @@ class File(AbstractFile):
         self.context.add_query(qry)
         return return_type
 
+    def get_pre_authorized_access_url(self, expiration_hours):
+        # type: (int) -> ClientResult[str]
+        """Returns a link for downloading the file without authentication.
+        :param int expiration_hours: The number of hours until the link expires. If the maximum expiration time
+        defined in the web application is less than the specified expiration time, the maximum expiration time
+        takes precedence.
+        """
+        return_type = ClientResult(self.context, str())
+        params = {"expirationHours": expiration_hours}
+        qry = FunctionQuery(self, "GetPreAuthorizedAccessUrl", params, return_type)
+        self.context.add_query(qry)
+        return return_type
+
     def get_absolute_url(self):
         # type: () -> ClientResult[str]
         """Gets absolute url of a File"""
@@ -332,19 +342,18 @@ class File(AbstractFile):
         :param int flag: Specifies the kind of move operation.
         """
 
-        def _update_file(return_type, new_file_url):
-            return_type.set_property("ServerRelativeUrl", new_file_url)
-
         def _moveto(destination_folder):
-            """
-            :type destination_folder: Folder
-            """
-            file_path = "/".join([str(destination_folder.serverRelativeUrl), self.name])
+            # type: (Folder) -> None
+            file_url = "/".join([str(destination_folder.serverRelativeUrl), self.name])
 
-            params = {"newurl": file_path, "flags": flag}
+            params = {"newurl": file_url, "flags": flag}
             qry = ServiceOperationQuery(self, "moveto", params)
             self.context.add_query(qry)
-            self.context.after_query_execute(_update_file, self, file_path)
+
+            def _update_file(return_type):
+                self.set_property("ServerRelativeUrl", file_url)
+
+            self.context.after_query_execute(_update_file)
 
         def _source_file_resolved():
             if isinstance(destination, Folder):
@@ -366,10 +375,6 @@ class File(AbstractFile):
         :param int flag: Specifies the kind of move operation.
         """
 
-        def _update_file(return_type, new_file_url):
-            # type: (File, str) -> None
-            return_type.set_property("ServerRelativePath", new_file_url)
-
         def _move_to_using_path(destination_folder):
             # type: (Folder) -> None
             file_path = "/".join(
@@ -377,9 +382,12 @@ class File(AbstractFile):
             )
             params = {"DecodedUrl": file_path, "moveOperations": flag}
             qry = ServiceOperationQuery(self, "MoveToUsingPath", params)
-            self.context.add_query(qry).after_query_execute(
-                _update_file, self, file_path
-            )
+
+            def _update_file(return_type):
+                # type: (File) -> None
+                self.set_property("ServerRelativePath", file_path)
+
+            self.context.add_query(qry).after_query_execute(_update_file)
 
         def _source_file_resolved():
             if isinstance(destination, Folder):
@@ -493,6 +501,7 @@ class File(AbstractFile):
         return return_type
 
     def upload_with_checksum(self, upload_id, checksum, stream):
+        # type: (str, str, bytes) -> File
         """
         :param str upload_id: The upload session ID.
         :param str checksum:
@@ -924,9 +933,7 @@ class File(AbstractFile):
 
     @property
     def parent_folder(self):
-        """
-        :rtype: office365.sharepoint.folders.folder.Folder
-        """
+        # type: () -> Optional[Folder]
         if self.parent_collection is None:
             return None
         return self.parent_collection.parent

office365/sharepoint/folders/collection.py

@@ -1,7 +1,10 @@
+import os
+
 from office365.runtime.paths.service_operation import ServiceOperationPath
 from office365.runtime.paths.v3.entity import EntityPath
 from office365.runtime.queries.service_operation import ServiceOperationQuery
 from office365.sharepoint.entity_collection import EntityCollection
+from office365.sharepoint.folders.coloring_information import FolderColoringInformation
 from office365.sharepoint.folders.folder import Folder
 from office365.sharepoint.types.resource_path import ResourcePath as SPResPath
 
@@ -42,14 +45,28 @@ class FolderCollection(EntityCollection[Folder]):
             folder = folder.add(name)
         return folder
 
-    def add(self, name):
+    def add(self, name, color_hex=None):
         """Adds the folder that is located at the specified URL to the collection.
-        :param str name: Specifies the Name of the folder.
+        :param str name: Specifies the Name or Path of the folder.
+        :param str color_hex: Specifies the color of the folder.
         """
         return_type = Folder(self.context, EntityPath(name, self.resource_path))
-        self.add_child(return_type)
-        qry = ServiceOperationQuery(self, "Add", [name], None, None, return_type)
-        self.context.add_query(qry)
+        if color_hex:
+
+            def _add_coloring():
+                path = os.path.join(
+                    self.parent.properties.get("ServerRelativeUrl"), name
+                )
+                coloring_info = FolderColoringInformation(color_hex=color_hex)
+                self.context.folder_coloring.create_folder(
+                    path, coloring_info, return_type=return_type
+                )
+
+            self.parent.ensure_property("ServerRelativeUrl", _add_coloring)
+        else:
+            self.add_child(return_type)
+            qry = ServiceOperationQuery(self, "Add", [name], None, None, return_type)
+            self.context.add_query(qry)
         return return_type
 
     def get_by_url(self, url):

office365/sharepoint/folders/coloring.py

@@ -1,6 +1,10 @@
+from typing_extensions import Self
+
 from office365.runtime.queries.service_operation import ServiceOperationQuery
 from office365.sharepoint.entity import Entity
+from office365.sharepoint.folders.coloring_information import FolderColoringInformation
 from office365.sharepoint.folders.folder import Folder
+from office365.sharepoint.types.resource_path import ResourcePath as SPResPath
 
 
 class FolderColoring(Entity):
@@ -9,22 +13,19 @@ class FolderColoring(Entity):
     def create_folder(
         self,
         decoded_url,
-        ensure_unique_file_name=True,
-        overwrite=True,
-        coloring_information=None,
+        coloring_information=FolderColoringInformation(color_hex="1"),
+        return_type=None,
     ):
         """
         :param str decoded_url:
-        :param bool ensure_unique_file_name:
-        :param bool overwrite:
         :param FolderColoringInformation coloring_information:
+        :param Folder return_type: Return type
         """
-        return_type = Folder(self.context)
+        if return_type is None:
+            return_type = Folder(self.context)
 
         payload = {
-            "DecodedUrl": decoded_url,
-            "EnsureUniqueFileName": ensure_unique_file_name,
-            "Overwrite": overwrite,
+            "path": SPResPath(decoded_url),
             "coloringInformation": coloring_information,
         }
         qry = ServiceOperationQuery(
@@ -34,6 +35,7 @@ class FolderColoring(Entity):
         return return_type
 
     def stamp_color(self, decoded_url, coloring_information):
+        # type: (str, FolderColoringInformation) -> Self
         """
         :param str decoded_url:
         :param FolderColoringInformation coloring_information:

office365/sharepoint/folders/coloring_information.py

@@ -1,6 +1,40 @@
 from office365.runtime.client_value import ClientValue
 
 
+class FolderColors(object):
+    Yellow = "#FFCE3C"
+
+    Grey = "#B0B7BA"
+
+    DarkRed = "#E73E29"
+
+    LightRed = "#FFBCB2"
+
+    DarkOrange = "#EE7110"
+
+    LightOrange = "#FFBF84"
+
+    DarkGreen = "#3F9F4A"
+
+    LightGreen = "#8ED290"
+
+    DarkTeal = "#27938E"
+
+    LightTeal = "#7AD1CD"
+
+    DarkBlue = "#1E84D0"
+
+    LightBlue = "#86C8F7"
+
+    DarkPurple = "#9A61C7"
+
+    LightPurple = "#D4AFF6"
+
+    DarkPink = "#CC53B4"
+
+    LightPink = "#F7AAE7"
+
+
 class FolderColoringInformation(ClientValue):
     """"""
 
@@ -13,3 +47,7 @@ class FolderColoringInformation(ClientValue):
         self.ColorHex = color_hex
         self.ColorTag = color_tag
         self.Emoji = emoji
+
+    @property
+    def entity_type_name(self):
+        return "SP.FolderColoringInformation"

office365/sharepoint/folders/folder.py

@@ -30,7 +30,7 @@ class Folder(Entity):
     """Represents a folder in a SharePoint Web site."""
 
     def __str__(self):
-        return self.name
+        return self.name or self.entity_type_name
 
     def __repr__(self):
         return self.serverRelativeUrl or self.unique_id or self.entity_type_name
@@ -69,14 +69,14 @@ class Folder(Entity):
 
         return_type = FolderCollection(self.context, self.folders.resource_path, self)
 
-        def _loaded(parent):
+        def _get_folders(parent):
             # type: ("Folder") -> None
             [return_type.add_child(f) for f in parent.folders]
             if recursive:
                 for folder in parent.folders:
-                    folder.ensure_properties(["Folders"], _loaded, parent=folder)
+                    folder.ensure_properties(["Folders"], _get_folders, parent=folder)
 
-        self.ensure_properties(["Folders"], _loaded, parent=self)
+        self.ensure_properties(["Folders"], _get_folders, parent=self)
         return return_type
 
     def get_files(self, recursive=False):
@@ -88,16 +88,16 @@ class Folder(Entity):
 
         return_type = FileCollection(self.context, self.files.resource_path, self)
 
-        def _loaded(parent):
+        def _get_files(parent):
             # type: ("Folder") -> None
             [return_type.add_child(f) for f in parent.files]
             if recursive:
                 for folder in parent.folders:
                     folder.ensure_properties(
-                        ["Files", "Folders"], _loaded, parent=folder
+                        ["Files", "Folders"], _get_files, parent=folder
                     )
 
-        self.ensure_properties(["Files", "Folders"], _loaded, parent=self)
+        self.ensure_properties(["Files", "Folders"], _get_files, parent=self)
         return return_type
 
     def get_sharing_information(self):
@@ -115,18 +115,17 @@ class Folder(Entity):
             where to move a folder.
         """
 
-        def _update_folder(url):
-            self.set_property("ServerRelativeUrl", url)
-
         def _move_to(destination_folder):
             # type: ("Folder") -> None
             destination_url = "/".join(
                 [destination_folder.serverRelativeUrl, self.name]
             )
             qry = ServiceOperationQuery(self, "MoveTo", {"newUrl": destination_url})
-            self.context.add_query(qry).after_query_execute(
-                _update_folder, destination_url
-            )
+
+            def _update_folder(return_type):
+                self.set_property("ServerRelativeUrl", destination_url)
+
+            self.context.add_query(qry).after_query_execute(_update_folder)
 
         def _source_folder_resolved():
             if isinstance(destination, Folder):
@@ -146,21 +145,20 @@ class Folder(Entity):
             where to move a folder.
         """
 
-        def _update_folder(url):
-            self.set_property("ServerRelativePath", url)
-
         def _move_to_using_path(destination_folder):
             # type: ("Folder") -> None
-            destination_url = "/".join(
+            destination_path = "/".join(
                 [str(destination_folder.server_relative_path), self.name]
             )
             qry = ServiceOperationQuery(
-                self, "MoveToUsingPath", {"DecodedUrl": destination_url}
-            )
-            self.context.add_query(qry).after_query_execute(
-                _update_folder, destination_url
+                self, "MoveToUsingPath", {"DecodedUrl": destination_path}
             )
 
+            def _update_folder(url):
+                self.set_property("ServerRelativePath", destination_path)
+
+            self.context.add_query(qry).after_query_execute(_update_folder)
+
         def _source_folder_resolved():
             if isinstance(destination, Folder):
                 destination.ensure_property(
@@ -487,7 +485,9 @@ class Folder(Entity):
 
         return self.properties.get(
             "Folders",
-            FolderCollection(self.context, ResourcePath("Folders", self.resource_path)),
+            FolderCollection(
+                self.context, ResourcePath("Folders", self.resource_path), self
+            ),
         )
 
     @property

office365/sharepoint/likes/liked_by_information.py

@@ -1,3 +1,5 @@
+from typing import Optional
+
 from office365.runtime.paths.resource_path import ResourcePath
 from office365.sharepoint.entity import Entity
 from office365.sharepoint.entity_collection import EntityCollection
@@ -9,24 +11,19 @@ class LikedByInformation(Entity):
 
     @property
     def like_count(self):
-        """
-        Number of users that have liked the item.
-
-        :rtype: int or None
-        """
+        # type: () -> Optional[int]
+        """Number of users that have liked the item."""
         return self.properties.get("LikeCount", None)
 
     @property
     def is_liked_by_user(self):
-        """
-        MUST be TRUE if the current user has liked the list item.
-
-        :rtype: bool or None
-        """
+        # type: () -> Optional[bool]
+        """MUST be TRUE if the current user has liked the list item."""
         return self.properties.get("isLikedByUser", None)
 
     @property
     def liked_by(self):
+        # type: () -> EntityCollection[UserEntity]
         """
         List of like entries corresponding to individual likes. MUST NOT contain more than one entry
         for the same user in the set.

office365/sharepoint/likes/user_entity.py

@@ -1,3 +1,5 @@
+from typing import Optional
+
 from office365.sharepoint.entity import Entity
 
 
@@ -6,16 +8,12 @@ class UserEntity(Entity):
 
     @property
     def creation_date(self):
-        """
-        The Datetime of the like.
-        """
+        # type: () -> Optional[str]
+        """The Datetime of the like."""
         return self.properties.get("creationDate", None)
 
     @property
     def email(self):
-        """
-        The email of the user who liked the item.
-
-        :rtype: str
-        """
+        # type: () -> Optional[str]
+        """The email of the user who liked the item."""
         return self.properties.get("email", None)

office365/sharepoint/listitems/form_update_value.py

@@ -7,7 +7,14 @@ from office365.sharepoint.fields.lookup_value import FieldLookupValue
 class ListItemFormUpdateValue(ClientValue):
     """Specifies the properties of a list item field and its value."""
 
-    def __init__(self, name=None, value=None, has_exception=None, error_code=None):
+    def __init__(
+        self,
+        name=None,
+        value=None,
+        has_exception=None,
+        error_code=None,
+        error_message=None,
+    ):
         """
         :param str name: Specifies the field internal name for a field.
         :param str value: Specifies a value for a field.
@@ -19,6 +26,15 @@ class ListItemFormUpdateValue(ClientValue):
         self.FieldValue = value
         self.HasException = has_exception
         self.ErrorCode = error_code
+        self.ErrorMessage = error_message
+
+    def __repr__(self):
+        if self.HasException:
+            return "{0} update failed: Message: {1}".format(
+                self.FieldName, self.ErrorMessage
+            )
+        else:
+            return "{0} update succeeded".format(self.FieldName)
 
     def to_json(self, json_format=None):
         json = super(ListItemFormUpdateValue, self).to_json(json_format)

office365/sharepoint/listitems/listitem.py

@@ -212,13 +212,13 @@ class ListItem(SecurableObject):
 
         def _picker_value_resolved(picker_result):
             # type: (ClientResult) -> None
-            file_abs_url = self.get_property("EncodedAbsUrl")
+            abs_url = self.get_property("EncodedAbsUrl")
             picker_value = "[{0}]".format(picker_result.value)
             from office365.sharepoint.webs.web import Web
 
             Web.share_object(
                 self.context,
-                file_abs_url,
+                abs_url,
                 picker_value,
                 role_values[share_option],
                 0,

office365/sharepoint/lists/bloom_filter.py

@@ -1,3 +1,5 @@
+from typing import Optional
+
 from office365.runtime.client_value_collection import ClientValueCollection
 from office365.sharepoint.entity import Entity
 
@@ -7,15 +9,11 @@ class ListBloomFilter(Entity):
 
     @property
     def bloom_filter_size(self):
-        """
-        The length of the Bloom Filter
-        :rtype: int or None
-        """
+        # type: () -> Optional[int]
+        """The length of the Bloom Filter"""
         return self.properties.get("BloomFilterSize", None)
 
     @property
     def index_map(self):
-        """
-        Specifies a list of bloom indexes for item.
-        """
+        """Specifies a list of bloom indexes for item."""
         return self.properties.get("IndexMap", ClientValueCollection(int))