Office365-REST-Python-Client 2.5.1__py3-none-any.whl → 2.5.3__py3-none-any.whl

office365/sharepoint/fields/field.py

@@ -14,6 +14,9 @@ class Field(Entity):
     def __init__(self, context, resource_path=None):
         super(Field, self).__init__(context, resource_path)
 
+    def __repr__(self):
+        return self.internal_name or self.id
+
     @staticmethod
     def resolve_field_type(type_id_or_name):
         from office365.sharepoint.fields.calculated import FieldCalculated
@@ -138,9 +141,7 @@ class Field(Entity):
 
     @property
     def default_formula(self):
-        """
-        :rtype: str or None
-        """
+        # type: () -> Optional[str]
         return self.properties.get("DefaultFormula", None)
 
     @property
@@ -155,9 +156,9 @@ class Field(Entity):
 
     @property
     def schema_xml(self):
-        """Gets a value that specifies the XML schema that defines the field.
-
-        :rtype: str or None
+        # type: () -> Optional[str]
+        """
+        Gets a value that specifies the XML schema that defines the field.
         """
         return self.properties.get("SchemaXml", None)
 
@@ -168,41 +169,32 @@ class Field(Entity):
 
     @property
     def type_as_string(self):
-        """Gets a value that specifies the type of the field..
-
-        :rtype: str or None
-        """
+        # type: () -> Optional[str]
+        """Gets a value that specifies the type of the field"""
         return self.properties.get("TypeAsString", None)
 
     @property
     def title(self):
-        """Gets a value that specifies the display name of the field.
-
-        :rtype: str or None
-        """
+        # type: () -> Optional[str]
+        """Gets a value that specifies the display name of the field."""
         return self.properties.get("Title", None)
 
     @title.setter
     def title(self, val):
         """
         Sets a value that specifies the display name of the field.
-        :rtype: str or None
         """
         self.set_property("Title", val)
 
     @property
     def group(self):
-        """
-        Gets a value that specifies the field group.
-        :rtype: str or None
-        """
+        # type: () -> Optional[str]
+        """Gets a value that specifies the field group"""
         return self.properties.get("Group", None)
 
     @group.setter
     def group(self, val):
-        """Sets a value that specifies the field group.
-        :rtype: str or None
-        """
+        """Sets a value that specifies the field group."""
         self.set_property("Group", val)
 
     @property
@@ -215,71 +207,65 @@ class Field(Entity):
 
     @property
     def can_be_deleted(self):
+        # type: () -> Optional[bool]
         """
         Gets a value that specifies whether the field can be deleted
-        :rtype: bool or None
         """
         return self.properties.get("CanBeDeleted", None)
 
     @property
     def client_side_component_id(self):
-        """
-        :rtype: str or None
-        """
+        # type: () -> Optional[str]
         return self.properties.get("ClientSideComponentId", None)
 
     @property
     def client_side_component_properties(self):
-        """
-        :rtype: str or None
-        """
+        # type: () -> Optional[str]
         return self.properties.get("ClientSideComponentProperties", None)
 
     @property
     def client_validation_formula(self):
-        """
-        :rtype: str or None
-        """
+        # type: () -> Optional[str]
         return self.properties.get("ClientValidationFormula", None)
 
     @property
     def enforce_unique_values(self):
+        # type: () -> Optional[bool]
         """
         Specifies whether the field enforces unique values.
-        :rtype: bool or None
         """
         return self.properties.get("enforceUniqueValues", None)
 
     @property
     def filterable(self):
+        # type: () -> Optional[bool]
         """
         Specifies whether list items in the list can be filtered by the field value.
-        :rtype: bool or None
         """
         return self.properties.get("Filterable", None)
 
     @property
     def from_base_type(self):
+        # type: () -> Optional[bool]
         """
         Gets a Boolean value that indicates whether the field derives from a base field type.
-        :rtype: bool or None
         """
         return self.properties.get("FromBaseType", None)
 
     @property
     def js_link(self):
+        # type: () -> Optional[str]
         """
         When implemented in a derived class, gets or sets the name of an external JavaScript file that contains
         any client rendering logic for fields of the derived type.
-        :rtype: str or None
         """
         return self.properties.get("JSLink", None)
 
     @property
     def hidden(self):
+        # type: () -> Optional[bool]
         """
         Gets a value that specifies whether the field is hidden in list views and list forms.
-        :rtype: bool or None
         """
         return self.properties.get("Hidden", None)
 
@@ -292,25 +278,25 @@ class Field(Entity):
 
     @property
     def no_crawl(self):
+        # type: () -> Optional[bool]
         """
         Gets value that specifies whether the field can be crawled by a search engine.
-        :rtype: bool or None
         """
         return self.properties.get("NoCrawl", None)
 
     @property
     def read_only_field(self):
+        # type: () -> Optional[bool]
         """
         Specifies whether the value of the field is read-only.
-        :rtype: bool or None
         """
         return self.properties.get("ReadOnlyField", None)
 
     @property
     def default_value(self):
+        # type: () -> Optional[str]
         """
         Gets  a value that specifies the default value for the field.
-        :rtype: str or None
         """
         return self.properties.get("DefaultValue", None)
 
@@ -323,16 +309,13 @@ class Field(Entity):
 
     @property
     def indexed(self):
-        """
-        :rtype: str or None
-        """
         return self.properties.get("Indexed", None)
 
     @property
     def type_display_name(self):
+        # type: () -> Optional[str]
         """
         Gets a value that specifies the display name for the type of the field.
-        :rtype: str or None
         """
         return self.properties.get("TypeDisplayName", None)
 
@@ -348,10 +331,9 @@ class Field(Entity):
 
     @property
     def type_short_description(self):
+        # type: () -> Optional[str]
         """
         Gets a value that specifies the description for the type of the field.
-
-        :rtype: str or None
         """
         return self.properties.get("TypeShortDescription", None)
 

office365/sharepoint/fields/related_field_collection.py

@@ -3,7 +3,7 @@ from office365.sharepoint.entity_collection import EntityCollection
 from office365.sharepoint.fields.related_field import RelatedField
 
 
-class RelatedFieldCollection(EntityCollection):
+class RelatedFieldCollection(EntityCollection[RelatedField]):
     """Represents a collection of RelatedField resources."""
 
     def __init__(self, context, resource_path=None):

office365/sharepoint/fields/user_value.py

@@ -1,4 +1,5 @@
 from office365.sharepoint.fields.lookup_value import FieldLookupValue
+from office365.sharepoint.principal.users.user import User
 
 
 class FieldUserValue(FieldLookupValue):
@@ -8,11 +9,10 @@ class FieldUserValue(FieldLookupValue):
 
     @staticmethod
     def from_user(user):
+        # type: (User) -> FieldUserValue
         """
         Initialize field value from User
-
-        :param office365.sharepoint.principal.user.User user: User entity
-        :return: FieldUserValue
+        :param User user: User object
         """
         return_type = FieldUserValue(-1)
 

office365/sharepoint/files/checked_out_file.py

@@ -1,5 +1,5 @@
-from office365.runtime.paths.key import KeyPath
 from office365.runtime.paths.resource_path import ResourcePath
+from office365.runtime.paths.v3.entity import EntityPath
 from office365.runtime.queries.service_operation import ServiceOperationQuery
 from office365.sharepoint.entity import Entity
 from office365.sharepoint.principal.users.user import User
@@ -43,5 +43,7 @@ class CheckedOutFile(Entity):
         super(CheckedOutFile, self).set_property(name, value, persist_changes)
         # fallback: create a new resource path
         if name == "CheckedOutById":
-            self._resource_path = KeyPath(value, self.parent_collection.resource_path)
+            self._resource_path = EntityPath(
+                value, self.parent_collection.resource_path
+            )
         return self

office365/sharepoint/files/checked_out_file_collection.py

@@ -3,7 +3,7 @@ from office365.sharepoint.entity_collection import EntityCollection
 from office365.sharepoint.files.checked_out_file import CheckedOutFile
 
 
-class CheckedOutFileCollection(EntityCollection):
+class CheckedOutFileCollection(EntityCollection[CheckedOutFile]):
     def __init__(self, context, resource_path=None):
         super(CheckedOutFileCollection, self).__init__(
             context, CheckedOutFile, resource_path

office365/sharepoint/files/collection.py

@@ -1,23 +1,31 @@
+import hashlib
 import os
+import uuid
+from typing import IO, TYPE_CHECKING, Callable
 
+from office365.runtime.client_result import ClientResult
+from office365.runtime.paths.resource_path import ResourcePath
 from office365.runtime.paths.service_operation import ServiceOperationPath
 from office365.runtime.queries.service_operation import ServiceOperationQuery
+from office365.sharepoint.client_context import ClientContext
 from office365.sharepoint.entity_collection import EntityCollection
 from office365.sharepoint.files.creation_information import FileCreationInformation
 from office365.sharepoint.files.file import File
-from office365.sharepoint.internal.queries.upload_session import (
-    create_upload_session_query_ex,
-)
 from office365.sharepoint.types.resource_path import ResourcePath as SPResPath
 
+if TYPE_CHECKING:
+    from office365.sharepoint.folders.folder import Folder
+
 
 class FileCollection(EntityCollection[File]):
     """Represents a collection of File resources."""
 
     def __init__(self, context, resource_path=None, parent=None):
+        # type: (ClientContext, ResourcePath, Folder) -> None
         super(FileCollection, self).__init__(context, File, resource_path, parent)
 
     def upload(self, path_or_file):
+        # type: (str|IO) -> File
         """Uploads a file into folder.
 
         Note: This method only supports files up to 4MB in size!
@@ -34,22 +42,77 @@ class FileCollection(EntityCollection[File]):
             name = os.path.basename(path_or_file)
             return self.add(name, content, True)
 
+    def upload_with_checksum(self, file_object, chunk_size=1024):
+        # type: (IO, int) -> File
+        """ """
+        h = hashlib.sha1()  # hashlib.md5()
+        file_name = os.path.basename(file_object.name)
+        upload_id = str(uuid.uuid4())
+
+        def _upload_session(return_type):
+            # 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)
+
+        return self.add(file_name, None, True).after_execute(_upload_session)
+
     def create_upload_session(
-        self, path_or_file, chunk_size, chunk_uploaded=None, **kwargs
+        self, file, chunk_size, chunk_uploaded=None, file_name=None, **kwargs
     ):
+        # type: (IO|str, int, Callable[[int, ...], None], str, ...) -> File
         """Upload a file as multiple chunks
-
-        :param str or typing.IO path_or_file: path where file to upload resides or file handle
+        :param str or typing.IO file: path where file to upload resides or file handle
         :param int chunk_size: upload chunk size (in bytes)
         :param (long)->None or None chunk_uploaded: uploaded event
+        :param str file_name: custom file name
         :param kwargs: arguments to pass to chunk_uploaded function
         """
 
-        qry = create_upload_session_query_ex(
-            self, path_or_file, chunk_size, chunk_uploaded, **kwargs
-        )
-        self.context.add_query(qry)
-        return qry.return_type
+        auto_close = False
+        if not hasattr(file, "read"):
+            file = open(file, "rb")
+            auto_close = True
+
+        file_size = os.fstat(file.fileno()).st_size
+        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
+
+            uploaded_bytes = file.tell()
+            if callable(chunk_uploaded):
+                chunk_uploaded(uploaded_bytes, **kwargs)
+
+            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
+                )
+            elif uploaded_bytes + len(content) < file_size:
+                return_file.continue_upload(
+                    upload_id, uploaded_bytes, content
+                ).after_execute(_upload_session, return_file)
+            else:
+                return_file.finish_upload(
+                    upload_id, uploaded_bytes, content
+                ).after_execute(_upload_session, return_file)
+
+        if file_size > chunk_size:
+            return self.add(file_name, None, True).after_execute(_upload_session, None)
+        else:
+            return self.add(file_name, file.read(), True)
 
     def add(self, url, content, overwrite=False):
         """
@@ -60,7 +123,7 @@ class FileCollection(EntityCollection[File]):
             or absolute form. Its length MUST be equal to or greater than 1.
         :param bool overwrite: Specifies whether to overwrite an existing file with the same name and in the same
             location as the one being added.
-        :param str or bytes content: Specifies the binary content of the file to be added.
+        :param str or bytes or None content: Specifies the binary content of the file to be added.
         """
         return_type = File(self.context)
         self.add_child(return_type)
@@ -80,7 +143,7 @@ class FileCollection(EntityCollection[File]):
         return_type = File(self.context)
         self.add_child(return_type)
 
-        def _parent_folder_loaded():
+        def _add_template_file():
             params = {
                 "urlOfFile": str(
                     SPResPath.create_relative(
@@ -94,17 +157,24 @@ class FileCollection(EntityCollection[File]):
             )
             self.context.add_query(qry)
 
-        self.parent.ensure_property("ServerRelativeUrl", _parent_folder_loaded)
+        self.parent.ensure_property("ServerRelativeUrl", _add_template_file)
         return return_type
 
     def get_by_url(self, url):
+        # type: (str) -> File
         """Retrieve File object by url"""
         return File(
             self.context, ServiceOperationPath("GetByUrl", [url], self.resource_path)
         )
 
     def get_by_id(self, _id):
+        # type: (int) -> File
         """Gets the File with the specified ID."""
         return File(
             self.context, ServiceOperationPath("getById", [_id], self.resource_path)
         )
+
+    @property
+    def parent(self):
+        # type: () -> Folder
+        return self._parent