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

office365/runtime/client_object_collection.py

@@ -1,4 +1,4 @@
-from typing import Callable, Generic, Iterator, List, Optional, Type, TypeVar
+from typing import Any, Callable, Generic, Iterator, List, Optional, Type, TypeVar
 
 from typing_extensions import Self
 
@@ -40,6 +40,8 @@ class ClientObjectCollection(ClientObject, Generic[T]):
             raise AttributeError(
                 "No class model for entity type '{0}' was found".format(self._item_type)
             )
+        if resource_path is None:
+            resource_path = ResourcePath(None, self.resource_path)
         client_object = self._item_type(
             context=self.context, resource_path=resource_path
         )  # type: T
@@ -66,9 +68,7 @@ class ClientObjectCollection(ClientObject, Generic[T]):
 
     def add_child(self, client_object):
         # type: (T) -> Self
-        """
-        Adds client object into collection
-        """
+        """Adds client object into collection"""
         client_object._parent_collection = self
         self._data.append(client_object)
         return self
@@ -110,7 +110,6 @@ class ClientObjectCollection(ClientObject, Generic[T]):
         # type: (str) -> Self
         """
         Allows clients to filter a collection of resources that are addressed by a request URL
-
         :param str expression: Filter expression, for example: 'Id eq 123'
         """
         self.query_options.filter = expression
@@ -134,17 +133,13 @@ class ClientObjectCollection(ClientObject, Generic[T]):
 
     def top(self, value):
         # type: (int) -> Self
-        """
-        Specifies the number of items in the queried collection to be included in the result
-        """
+        """Specifies the number of items in the queried collection to be included in the result"""
         self.query_options.top = value
         return self
 
     def paged(self, page_size=None, page_loaded=None):
         # type: (int, Callable[[Self], None]) -> Self
-        """
-        Retrieves via server-driven paging mode
-        """
+        """Retrieves via server-driven paging mode"""
         self._paged_mode = True
         if callable(page_loaded):
             self._page_loaded += page_loaded
@@ -152,6 +147,12 @@ class ClientObjectCollection(ClientObject, Generic[T]):
             self.top(page_size)
         return self
 
+    def after_execute(self, action, *args, **kwargs):
+        # type: (Callable[[Self, Any, Any], None], Any, Any) -> Self
+        super(ClientObjectCollection, self).after_execute(action, *args, **kwargs)
+        self._page_loaded += action
+        return self
+
     def get(self):
         # type: () -> Self
 
@@ -196,22 +197,22 @@ class ClientObjectCollection(ClientObject, Generic[T]):
     def first(self, expression):
         # type: (str) -> T
         """Return the first Entity instance that matches current query
-
         :param str expression: Filter expression
         """
         return_type = self.create_typed_object()
         self.add_child(return_type)
-        key = return_type.property_ref_name
 
         def _after_loaded(col):
             # type: (ClientObjectCollection) -> None
             if len(col) < 1:
                 message = "Not found for filter: {0}".format(self.query_options.filter)
                 raise ValueError(message)
-            return_type.set_property(key, col[0].get_property(key))
+            [
+                return_type.set_property(k, v, False)
+                for k, v in col[0].properties.items()
+            ]
 
-        self.filter(expression).top(1)
-        self.context.load(self, [key], after_loaded=_after_loaded)
+        self.get().filter(expression).top(1).after_execute(_after_loaded)
         return return_type
 
     def single(self, expression):
@@ -223,7 +224,6 @@ class ClientObjectCollection(ClientObject, Generic[T]):
         """
         return_type = self.create_typed_object()
         self.add_child(return_type)
-        key = return_type.property_ref_name
 
         def _after_loaded(col):
             # type: (ClientObjectCollection) -> None
@@ -233,10 +233,12 @@ class ClientObjectCollection(ClientObject, Generic[T]):
             elif len(col) > 1:
                 message = "Ambiguous match found for filter: {0}".format(expression)
                 raise ValueError(message)
-            return_type.set_property(key, col[0].get_property(key), False)
+            [
+                return_type.set_property(k, v, False)
+                for k, v in col[0].properties.items()
+            ]
 
-        self.filter(expression).top(2)
-        self.context.load(self, after_loaded=_after_loaded)
+        self.get().filter(expression).top(2).after_execute(_after_loaded)
         return return_type
 
     @property

office365/runtime/client_result.py

@@ -59,9 +59,7 @@ class ClientResult(Generic[T]):
     def execute_query_retry(
         self, max_retry=5, timeout_secs=5, success_callback=None, failure_callback=None
     ):
-        """
-        Executes the current set of data retrieval queries and method invocations and retries it if needed.
-        """
+        """Executes the current set of data retrieval queries and method invocations and retries it if needed."""
         self._context.execute_query_retry(
             max_retry=max_retry,
             timeout_secs=timeout_secs,

office365/runtime/client_value_collection.py

@@ -41,9 +41,7 @@ class ClientValueCollection(ClientValue, Generic[T]):
 
     def to_json(self, json_format=None):
         # type: (ODataJsonFormat) -> list
-        """
-        Serializes a client value's collection
-        """
+        """Serializes a client value's collection"""
         json = [v for v in self]
         for i, v in enumerate(json):
             if isinstance(v, ClientValue):
@@ -81,7 +79,5 @@ class ClientValueCollection(ClientValue, Generic[T]):
 
     @property
     def entity_type_name(self):
-        """
-        Returns server type name of value's collection
-        """
+        """Returns server type name of value's collection"""
         return "Collection({0})".format(ODataType.resolve_type(self._item_type))

office365/runtime/odata/query_options.py

@@ -90,9 +90,7 @@ class QueryOptions(object):
         self.custom = {}
 
     def to_url(self):
-        """Convert query options to url
-        :return: str
-        """
+        """Convert query options to url"""
         return "&".join(["$%s=%s" % (key, value) for (key, value) in self])
 
     def __iter__(self):

office365/runtime/odata/type.py

@@ -64,6 +64,8 @@ class ODataType(object):
         """
         if value is None:
             return None
+        elif isinstance(value, datetime.datetime):
+            return value
 
         known_formats = [
             "%Y-%m-%dT%H:%M:%SZ",

office365/runtime/paths/appid.py

@@ -7,7 +7,7 @@ class AppIdPath(ResourcePath):
 
     @property
     def segment(self):
-        return "(appId='{0}')".format(self.key)
+        return "(appId='{0}')".format(self._key)
 
     @property
     def delimiter(self):

office365/runtime/{odata/url_builder.py → paths/builder.py}

@@ -1,18 +1,33 @@
 import json
+import re
+from typing import TYPE_CHECKING
 
 from office365.runtime.client_value import ClientValue
 from office365.runtime.compat import is_string_type
+from office365.runtime.paths.resource_path import ResourcePath
 
+if TYPE_CHECKING:
+    from office365.runtime.paths.service_operation import ServiceOperationPath
 
-class ODataUrlBuilder(object):
+
+class ODataPathBuilder(object):
     @staticmethod
-    def build_segment(path):
-        """
-        Constructs url for path segment
+    def parse_url(path_str):
+        # type: (str) -> ResourcePath
+        """Parses path from a string"""
+        segments = [n for n in re.split(r"[('')]|/", path_str) if n]
+        if not segments:
+            raise TypeError("Invalid path")
+        path = None
+        for segment in segments:
+            path = ResourcePath(segment, path)
+        return path
 
-        :type path: office365.runtime.paths.service_operation.ServiceOperationPath
-        """
-        url = path.key or ""
+    @staticmethod
+    def build_segment(path):
+        # type: (ServiceOperationPath) -> str
+        """Constructs url for path segment"""
+        url = path.name or ""
         if isinstance(path.parameters, ClientValue):
             url += "(@v)?@v={0}".format(json.dumps(path.parameters.to_json()))
         elif path.parameters is not None:
@@ -20,7 +35,7 @@ class ODataUrlBuilder(object):
             if isinstance(path.parameters, dict):
                 url += ",".join(
                     [
-                        "%s=%s" % (key, ODataUrlBuilder._encode_method_value(value))
+                        "%s=%s" % (key, ODataPathBuilder._encode_method_value(value))
                         for (key, value) in path.parameters.items()
                         if value is not None
                     ]
@@ -28,7 +43,7 @@ class ODataUrlBuilder(object):
             else:
                 url += ",".join(
                     [
-                        "%s" % (ODataUrlBuilder._encode_method_value(value))
+                        "%s" % (ODataPathBuilder._encode_method_value(value))
                         for (i, value) in enumerate(path.parameters)
                         if value is not None
                     ]

office365/runtime/paths/item.py

@@ -1,4 +1,4 @@
-from office365.runtime.paths.entity import EntityPath
+from office365.runtime.paths.v4.entity import EntityPath
 
 
 class ItemPath(EntityPath):

office365/runtime/paths/resource_path.py

@@ -1,18 +1,21 @@
+from typing import Iterator
+
+
 class ResourcePath(object):
     """OData resource path"""
 
-    def __init__(self, key, parent=None):
-        """
-        :type key: int or str
-        :type parent: ResourcePath or None
-        """
+    def __init__(self, key=None, parent=None):
+        # type: (int|str, "ResourcePath") -> None
         self._key = key
         self._parent = parent
 
-    def patch(self, key, inplace=False):
+    def patch(self, key):
+        if self._key is None:
+            self._key = key
         return self
 
     def __iter__(self):
+        # type: () -> Iterator["ResourcePath"]
         current = self
         while current:
             yield current
@@ -25,11 +28,8 @@ class ResourcePath(object):
         return self.to_url()
 
     def to_url(self):
-        """
-        Builds url
-
-        :rtype: str
-        """
+        # type: () -> str
+        """Builds url"""
         segments = []
         for path in self:
             segments.insert(0, path.segment)
@@ -43,11 +43,7 @@ class ResourcePath(object):
 
     @property
     def segment(self):
-        return str(self.key)
-
-    @property
-    def key(self):
-        return self._key
+        return str(self._key)
 
     @property
     def delimiter(self):

office365/runtime/paths/service_operation.py

@@ -1,4 +1,5 @@
-from office365.runtime.odata.url_builder import ODataUrlBuilder
+from office365.runtime.client_value import ClientValue
+from office365.runtime.paths.builder import ODataPathBuilder
 from office365.runtime.paths.resource_path import ResourcePath
 
 
@@ -6,17 +7,17 @@ class ServiceOperationPath(ResourcePath):
     """Path to address Service Operations which represents simple functions exposed by an OData service"""
 
     def __init__(self, name, parameters=None, parent=None):
-        """
-        :type parameters: list or dict or office365.runtime.client_value.ClientValue or None
-        :type name: str
-        :type parent: office365.runtime.paths.resource_path.ResourcePath
-        """
+        # type: (str, list|dict|ClientValue, ResourcePath) -> None
         super(ServiceOperationPath, self).__init__(name, parent)
         self._parameters = parameters
 
     @property
     def segment(self):
-        return ODataUrlBuilder.build_segment(self)
+        return ODataPathBuilder.build_segment(self)
+
+    @property
+    def name(self):
+        return self._key
 
     @property
     def parameters(self):

office365/runtime/paths/{key.py → v3/entity.py}

@@ -1,16 +1,16 @@
 from office365.runtime.paths.resource_path import ResourcePath
 
 
-class KeyPath(ResourcePath):
+class EntityPath(ResourcePath):
     """Path for addressing a single entity by key"""
 
     @property
     def segment(self):
-        if self.key is None:
+        if self._key is None:
             return "(<key>)"
-        elif isinstance(self.key, int):
-            return "({0})".format(self.key)
-        return "('{0}')".format(self.key)
+        elif isinstance(self._key, int):
+            return "({0})".format(self._key)
+        return "('{0}')".format(self._key)
 
     @property
     def delimiter(self):

office365/runtime/paths/{entity.py → v4/entity.py}

@@ -12,23 +12,25 @@ class EntityPath(ResourcePath):
 
     @property
     def collection(self):
+        from office365.onedrive.internal.paths.children import ChildrenPath
+
+        if self._collection is None:
+            if isinstance(self.parent, ChildrenPath):
+                self._collection = self.parent.collection
+            else:
+                self._collection = self.parent
         return self._collection
 
     @property
     def segment(self):
-        return str(self.key or "<key>")
+        return str(self._key or "<key>")
 
-    def patch(self, key, inplace=False):
+    def patch(self, key):
         """
         Patches path
-
         :type key: str or None
-        :type inplace: bool
         """
-        if inplace:
-            self._key = key
-            self._parent = self.collection
-            self.__class__ = ResourcePath
-            return self
-        else:
-            return ResourcePath(key, self.collection)
+        self._key = key
+        self._parent = self.collection
+        self.__class__ = EntityPath
+        return self

office365/sharepoint/contenttypes/content_type.py

@@ -19,6 +19,12 @@ class ContentType(Entity):
     to items of those types
     """
 
+    def __str__(self):
+        return self.name
+
+    def __repr__(self):
+        return self.string_id or str(self.id) or self.entity_type_name
+
     def reorder_fields(self, field_names):
         """
         The ReorderFields method is called to change the order in which fields appear in a content type.

office365/sharepoint/documentmanagement/document_set.py

@@ -1,6 +1,8 @@
 from office365.runtime.http.http_method import HttpMethod
+from office365.runtime.http.request_options import RequestOptions
 from office365.runtime.queries.client_query import ClientQuery
 from office365.sharepoint.folders.folder import Folder
+from office365.sharepoint.lists.list import List
 
 
 class DocumentSet(Folder):
@@ -26,18 +28,14 @@ class DocumentSet(Folder):
             target_list.ensure_property("Title", _create, target_list=target_list)
 
         def _create(target_list):
-            """
-            :type target_list: office365.sharepoint.lists.list.List
-            """
+            # type: (List) -> None
             qry = ClientQuery(context, return_type=return_type)
             context.add_query(qry)
             folder_url = parent_folder.serverRelativeUrl + "/" + name
             return_type.set_property("ServerRelativeUrl", folder_url)
 
             def _construct_request(request):
-                """
-                :type request: office365.runtime.http.request_options.RequestOptions
-                """
+                # type: (RequestOptions) -> None
                 list_name = target_list.title.replace(" ", "")
                 request.url = r"{0}/_vti_bin/listdata.svc/{1}".format(
                     context.base_url, list_name

office365/sharepoint/entity_collection.py

@@ -2,6 +2,7 @@ from typing import TYPE_CHECKING, Optional, Type, TypeVar
 
 from office365.runtime.client_object_collection import ClientObjectCollection
 from office365.runtime.paths.resource_path import ResourcePath
+from office365.runtime.paths.v3.entity import EntityPath
 from office365.sharepoint.entity import Entity
 
 if TYPE_CHECKING:
@@ -21,6 +22,14 @@ class EntityCollection(ClientObjectCollection[T]):
             context, item_type, resource_path, parent
         )
 
+    def create_typed_object(self, initial_properties=None, resource_path=None):
+        # type: (Optional[dict], Optional[ResourcePath]) -> T
+        if resource_path is None:
+            resource_path = EntityPath(None, self.resource_path)
+        return super(EntityCollection, self).create_typed_object(
+            initial_properties, resource_path
+        )
+
     @property
     def context(self):
         # type: () -> ClientContext

office365/sharepoint/features/feature.py

@@ -1,3 +1,5 @@
+from typing import Optional
+
 from office365.sharepoint.entity import Entity
 
 
@@ -6,16 +8,12 @@ class Feature(Entity):
 
     @property
     def definition_id(self):
-        """
-        Gets the GUID that identifies this feature.
-        :rtype: str or None
-        """
+        # type: () -> Optional[str]
+        """Gets the GUID that identifies this feature."""
         return self.properties.get("DefinitionId", None)
 
     @property
     def display_name(self):
-        """
-        Gets the GUID that identifies this feature.
-        :rtype: str or None
-        """
+        # type: () -> Optional[str]
+        """Gets the GUID that identifies this feature."""
         return self.properties.get("DisplayName", None)

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, Callable
+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.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,6 +42,23 @@ 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, file, chunk_size, chunk_uploaded=None, file_name=None, **kwargs
     ):
@@ -118,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(
@@ -132,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