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

office365/planner/plans/collection.py

@@ -1,43 +1,42 @@
-from office365.directory.users.user import User
+from office365.directory.groups.group import Group
 from office365.entity_collection import EntityCollection
 from office365.planner.plans.plan import PlannerPlan
 from office365.runtime.queries.create_entity import CreateEntityQuery
 
 
-class PlannerPlanCollection(EntityCollection):
+class PlannerPlanCollection(EntityCollection[PlannerPlan]):
     def __init__(self, context, resource_path=None):
         super(PlannerPlanCollection, self).__init__(context, PlannerPlan, resource_path)
 
-    def add(self, title, owner=None):
-        """
-        Creates a new plannerPlan.
-
-        :param str title: Planner name
-        :param str or office365.directory.users.user.User owner: Planner owner
+    def add(self, title, container):
+        # type: (str, str|Group) -> PlannerPlan
+        """Creates a new plannerPlan.
+        :param str title: Plan title
+        :param str or Group container: Identifies the container of the plan.
         """
         return_type = PlannerPlan(self.context)
         self.add_child(return_type)
 
-        def _create_query(owner_id):
+        def _add(owner_id):
+            # type: (str) -> None
             payload = {
                 "title": title,
-                "owner": {
-                    "@odata.id": "https://graph.microsoft.com/v1.0/users/{0}".format(
+                "container": {
+                    "url": "https://graph.microsoft.com/v1.0/groups/{0}".format(
                         owner_id
                     )
                 },
             }
-            return CreateEntityQuery(self, payload, return_type)
+            qry = CreateEntityQuery(self, payload, return_type)
+            self.context.add_query(qry)
 
-        if isinstance(owner, User):
+        if isinstance(container, Group):
 
             def _owner_loaded():
-                next_qry = _create_query(owner.id)
-                self.context.add_query(next_qry)
+                _add(container.id)
 
-            owner.ensure_property("id", _owner_loaded)
+            container.ensure_property("id", _owner_loaded)
         else:
-            qry = _create_query(owner)
-            self.context.add_query(qry)
+            _add(container)
 
         return return_type

office365/planner/plans/container.py

@@ -0,0 +1,11 @@
+from office365.runtime.client_value import ClientValue
+
+
+class PlannerPlanContainer(ClientValue):
+    """
+    Represents a container for a plannerPlan. The container is a resource that specifies authorization rules and the
+    lifetime of the plan. This means that only the people who are authorized to work with the resource containing
+    the plan will be able to work with the plan and the tasks within it. When the containing resource is deleted,
+    the contained plans are also deleted. The properties of the plannerPlanContainer cannot be changed after the plan
+    is created.
+    """

office365/planner/plans/plan.py

@@ -1,8 +1,11 @@
+from typing import Optional
+
 from office365.directory.permissions.identity_set import IdentitySet
 from office365.entity import Entity
 from office365.entity_collection import EntityCollection
 from office365.planner.buckets.bucket import PlannerBucket
-from office365.planner.plans.plan_details import PlannerPlanDetails
+from office365.planner.plans.container import PlannerPlanContainer
+from office365.planner.plans.details import PlannerPlanDetails
 from office365.planner.tasks.task import PlannerTask
 from office365.runtime.paths.resource_path import ResourcePath
 
@@ -14,8 +17,20 @@ class PlannerPlan(Entity):
     For more information about the relationships between groups, plans, and tasks, see Planner.
     """
 
+    def __str__(self):
+        return self.title
+
+    def __repr__(self):
+        return self.id or self.entity_type_name
+
+    @property
+    def container(self):
+        """Identity of the user, device, or application which created the plan."""
+        return self.properties.get("container", PlannerPlanContainer())
+
     @property
     def title(self):
+        # type: () -> Optional[str]
         """Required. Title of the plan."""
         return self.properties.get("title", None)
 
@@ -26,9 +41,8 @@ class PlannerPlan(Entity):
 
     @property
     def buckets(self):
-        """
-        Read-only. Nullable. Collection of buckets in the plan.
-        """
+        # type: () -> EntityCollection[PlannerBucket]
+        """Collection of buckets in the plan."""
         return self.properties.get(
             "buckets",
             EntityCollection(
@@ -38,9 +52,7 @@ class PlannerPlan(Entity):
 
     @property
     def details(self):
-        """
-        Read-only. Nullable. Additional details about the plan.
-        """
+        """Additional details about the plan."""
         return self.properties.get(
             "details",
             PlannerPlanDetails(
@@ -50,9 +62,8 @@ class PlannerPlan(Entity):
 
     @property
     def tasks(self):
-        """
-        Read-only. Nullable. Collection of tasks in the plan.
-        """
+        # type: () -> EntityCollection[PlannerTask]
+        """Collection of tasks in the plan."""
         return self.properties.get(
             "tasks",
             EntityCollection(

office365/runtime/auth/authentication_context.py

@@ -1,8 +1,8 @@
 import json
 import sys
-from typing import Any, Callable, TypedDict
+from typing import Any, Callable
 
-from typing_extensions import Required
+from typing_extensions import Required, TypedDict
 
 from office365.runtime.auth.client_credential import ClientCredential
 from office365.runtime.auth.providers.acs_token_provider import ACSTokenProvider
@@ -65,7 +65,7 @@ class AuthenticationContext(object):
                 "Private key is missing. Use either 'cert_path' or 'private_key' to pass the value"
             )
         elif cert_path is not None:
-            with open(cert_path, "r") as f:
+            with open(cert_path, "r", encoding="utf8") as f:
                 private_key = f.read()
 
         def _acquire_token():

office365/runtime/auth/providers/acs_token_provider.py

@@ -1,9 +1,12 @@
+from typing import Optional
+
 import requests
 
 import office365.logger
 from office365.runtime.auth.authentication_provider import AuthenticationProvider
 from office365.runtime.auth.token_response import TokenResponse
 from office365.runtime.compat import urlparse
+from office365.runtime.http.request_options import RequestOptions
 
 
 class ACSTokenProvider(AuthenticationProvider, office365.logger.LoggerContext):
@@ -24,9 +27,7 @@ class ACSTokenProvider(AuthenticationProvider, office365.logger.LoggerContext):
         self._cached_token = None
 
     def authenticate_request(self, request):
-        """
-        :type request: office365.runtime.http.request_options.RequestOptions
-        """
+        # type: (RequestOptions) -> None
         self.ensure_app_only_access_token()
         request.set_header("Authorization", self._get_authorization_header())
 
@@ -36,9 +37,7 @@ class ACSTokenProvider(AuthenticationProvider, office365.logger.LoggerContext):
         return self._cached_token and self._cached_token.is_valid
 
     def get_app_only_access_token(self):
-        """
-        Retrieves an app-only access token from ACS
-        """
+        """Retrieves an app-only access token from ACS"""
         try:
             realm = self._get_realm_from_target_url()
             url_info = urlparse(self.url)
@@ -86,9 +85,7 @@ class ACSTokenProvider(AuthenticationProvider, office365.logger.LoggerContext):
 
     @staticmethod
     def process_realm_response(response):
-        """
-        :type response: requests.Response
-        """
+        # type: (requests.Response) -> Optional[str]
         header_key = "WWW-Authenticate"
         if header_key in response.headers:
             auth_values = response.headers[header_key].split(",")
@@ -98,6 +95,7 @@ class ACSTokenProvider(AuthenticationProvider, office365.logger.LoggerContext):
 
     @staticmethod
     def get_formatted_principal(principal_name, host_name, realm):
+        # type: (str, Optional[str], str) -> str
         if host_name:
             return "{0}/{1}@{2}".format(principal_name, host_name, realm)
         return "{0}@{1}".format(principal_name, realm)

office365/runtime/auth/providers/saml_token_provider.py

@@ -1,6 +1,6 @@
 import os
 import uuid
-import xml.dom.minidom as minidom
+from xml.dom import minidom
 from xml.etree import ElementTree
 
 import requests
@@ -314,7 +314,10 @@ class SamlTokenProvider(AuthenticationProvider, office365.logger.LoggerContext):
         """Construct the request body to acquire security token from STS endpoint"""
         logger = SamlTokenProvider.logger()
         logger.debug_secrets("params: %s", params)
-        f = open(os.path.join(os.path.dirname(__file__), "templates", template_name))
+        f = open(
+            os.path.join(os.path.dirname(__file__), "templates", template_name),
+            encoding="utf8",
+        )
         try:
             data = f.read()
             for key in params:

office365/runtime/client_object.py

@@ -74,6 +74,7 @@ class ClientObject(Generic[T]):
         return self
 
     def after_execute(self, action, *args, **kwargs):
+        # type: (Callable[[Self, Any, Any], None], Any, Any) -> Self
         """
         Attach an event handler to client object which gets triggered after query is submitted to server
         """
@@ -89,7 +90,6 @@ class ClientObject(Generic[T]):
     def is_property_available(self, name):
         # type: (str) -> bool
         """Returns a Boolean value that indicates whether the specified property has been retrieved or set.
-
         :param str name: A property name
         """
         if name in self.properties:
@@ -115,7 +115,7 @@ class ClientObject(Generic[T]):
 
     def remove_from_parent_collection(self):
         if self._parent_collection is None:
-            return
+            return self
         self._parent_collection.remove_child(self)
         return self
 
@@ -149,9 +149,7 @@ class ClientObject(Generic[T]):
             self._ser_property_names.append(name)
 
         typed_value = self.get_property(name)
-        if isinstance(typed_value, ClientObject) or isinstance(
-            typed_value, ClientValue
-        ):
+        if isinstance(typed_value, (ClientObject, ClientValue)):
             if isinstance(value, list):
                 [
                     typed_value.set_property(i, v, persist_changes)
@@ -175,19 +173,12 @@ class ClientObject(Generic[T]):
 
     def ensure_property(self, name, action, *args, **kwargs):
         # type: (str, Callable[[], None], Any, Any) -> Self
-        """
-        Ensures if property is loaded
-
-        :type action: () -> None
-        :type name: str
-        """
+        """Ensures if property is loaded"""
         return self.ensure_properties([name], action, *args, **kwargs)
 
     def ensure_properties(self, names, action, *args, **kwargs):
         # type: (List[str], Callable[[Any, Any], None], Any, Any) -> Self
-        """
-        Ensure if list of properties are retrieved from the server
-        """
+        """Ensure if list of properties are retrieved from the server"""
         if self.property_ref_name is not None and self.property_ref_name not in names:
             names.append(self.property_ref_name)
 
@@ -260,7 +251,7 @@ class ClientObject(Generic[T]):
             k: self.get_property(k) for k in self._properties if k in ser_prop_names
         }
         for k, v in json.items():
-            if isinstance(v, ClientObject) or isinstance(v, ClientValue):
+            if isinstance(v, (ClientObject, ClientValue)):
                 json[k] = v.to_json(json_format)
 
         if json and include_control_info:

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,11 +68,7 @@ class ClientObjectCollection(ClientObject, Generic[T]):
 
     def add_child(self, client_object):
         # type: (T) -> Self
-        """
-        Adds client object into collection
-
-        :type client_object: ClientObject
-        """
+        """Adds client object into collection"""
         client_object._parent_collection = self
         self._data.append(client_object)
         return self
@@ -112,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
@@ -136,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[["ClientObjectCollection"], None]) -> Self
-        """
-        Retrieves via server-driven paging mode
-        """
+        # type: (int, Callable[[Self], None]) -> Self
+        """Retrieves via server-driven paging mode"""
         self._paged_mode = True
         if callable(page_loaded):
             self._page_loaded += page_loaded
@@ -154,10 +147,17 @@ 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
 
-        def _loaded(items):
+        def _loaded(col):
+            # type: (Self) -> None
             self._page_loaded.notify(self)
 
         self.context.load(self, after_loaded=_loaded)
@@ -165,17 +165,13 @@ class ClientObjectCollection(ClientObject, Generic[T]):
 
     def get_all(self, page_size=None, page_loaded=None):
         # type: (int, Callable[[Self], None]) -> Self
-        """
-        Gets all the items in a collection, regardless of the size.
+        """Gets all the items in a collection, regardless of the size."""
 
-        :type self: T
-        :param int page_size: Page size
-        :param (T) -> None page_loaded: Page loaded event
-        """
         self.paged(page_size, page_loaded)
 
-        def _page_loaded(items):
-            self._page_loaded.notify(self)
+        def _page_loaded(col):
+            # type: (Self) -> None
+            self._page_loaded.notify(col)
             if self.has_next:
                 self._get_next(after_loaded=_page_loaded)
 
@@ -186,38 +182,37 @@ class ClientObjectCollection(ClientObject, Generic[T]):
         # type: (Optional[EventHandler]) -> Self
         """
         Submit a request to retrieve next collection of items
-
         :param (ClientObjectCollection) -> None after_loaded: Page loaded event
         """
 
-        def _construct_next_query(request):
+        def _construct_request(request):
             # type: (RequestOptions) -> None
             request.url = self._next_request_url
 
         self.context.load(
-            self, before_loaded=_construct_next_query, after_loaded=after_loaded
+            self, before_loaded=_construct_request, after_loaded=after_loaded
         )
         return self
 
     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):
@@ -229,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
@@ -239,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
@@ -256,6 +252,11 @@ class ClientObjectCollection(ClientObject, Generic[T]):
         """"""
         return self._next_request_url is not None
 
+    @property
+    def current_page(self):
+        # type: () -> List[T]
+        return self._data[self._current_pos :]
+
     @property
     def entity_type_name(self):
         # type: () -> str

office365/runtime/client_result.py

@@ -1,11 +1,11 @@
 import copy
-from typing import TYPE_CHECKING, Generic, Optional, TypeVar
+from typing import TYPE_CHECKING, Any, Callable, Generic, Optional, TypeVar
 
 from typing_extensions import Self
 
 if TYPE_CHECKING:
-    from office365.runtime.client_runtime_context import ClientRuntimeContext
-    from office365.runtime.client_value import ClientValue
+    from office365.runtime.client_runtime_context import ClientRuntimeContext  # noqa
+    from office365.runtime.client_value import ClientValue  # noqa
 
 T = TypeVar("T")
 
@@ -28,6 +28,7 @@ class ClientResult(Generic[T]):
         return self
 
     def after_execute(self, action, *args, **kwargs):
+        # type: (Callable[[Self], None], Any, Any) -> Self
         """
         Attach an event handler which is triggered after query is submitted to server
         :param (ClientResult) -> None action: Event handler
@@ -37,7 +38,7 @@ class ClientResult(Generic[T]):
 
     def set_property(self, key, value, persist_changes=False):
         # type: (str, T, bool) -> Self
-        from office365.runtime.client_value import ClientValue
+        from office365.runtime.client_value import ClientValue  # noqa
 
         if isinstance(self._value, ClientValue):
             self._value.set_property(key, value, persist_changes)
@@ -58,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_runtime_context.py

@@ -5,9 +5,6 @@ from typing import TYPE_CHECKING, Any, AnyStr, Callable, List
 import requests
 from typing_extensions import Self
 
-if TYPE_CHECKING:
-    from office365.runtime.client_object import ClientObject
-
 from office365.runtime.client_request import ClientRequest
 from office365.runtime.client_request_exception import ClientRequestException
 from office365.runtime.client_result import ClientResult
@@ -16,6 +13,9 @@ from office365.runtime.http.request_options import RequestOptions
 from office365.runtime.queries.client_query import ClientQuery
 from office365.runtime.queries.read_entity import ReadEntityQuery
 
+if TYPE_CHECKING:
+    from office365.runtime.client_object import T
+
 
 class ClientRuntimeContext(object):
     def __init__(self):
@@ -88,17 +88,18 @@ class ClientRuntimeContext(object):
         before_loaded=None,
         after_loaded=None,
     ):
-        # type: (ClientObject, List[str], Callable[[RequestOptions], None], Callable[[ClientObject], None]) -> Self
+        # type: (T, List[str], Callable[[RequestOptions], None], Callable[[T], None]) -> Self
         """Prepare retrieval query"""
         qry = ReadEntityQuery(client_object, properties_to_retrieve)
         self.add_query(qry)
         if callable(before_loaded):
-            self.before_execute(before_loaded)
+            self.before_query_execute(before_loaded)
         if callable(after_loaded):
             self.after_query_execute(after_loaded, client_object)
         return self
 
     def before_query_execute(self, action, once=True, *args, **kwargs):
+        # type: (Callable[[RequestOptions, Any, Any], None], bool, Any, Any) -> Self
         """
         Attach an event handler which is triggered before query is submitted to server
 
@@ -110,10 +111,7 @@ class ClientRuntimeContext(object):
         query = self._queries[-1]
 
         def _prepare_request(request):
-            """
-            :type request: office365.runtime.http.request_options.RequestOptions
-            """
-
+            # type: (RequestOptions) -> None
             if self.current_query.id == query.id:
                 if once:
                     self.pending_request().beforeExecute -= _prepare_request
@@ -123,9 +121,9 @@ class ClientRuntimeContext(object):
         return self
 
     def before_execute(self, action, once=True, *args, **kwargs):
+        # type: (Callable[[RequestOptions, Any, Any], None], bool, Any, Any) -> Self
         """
         Attach an event handler which is triggered before request is submitted to server
-
         :param (office365.runtime.http.request_options.RequestOptions, any) -> None action:
         :param bool once: Flag which determines whether action is executed once or multiple times
         """
@@ -141,9 +139,7 @@ class ClientRuntimeContext(object):
 
     def after_query_execute(self, action, *args, **kwargs):
         # type: (Callable[[Any, Any], None], Any, Any) -> Self
-        """
-        Attach an event handler which is triggered after query is submitted to server
-        """
+        """Attach an event handler which is triggered after query is submitted to server"""
         if len(self._queries) == 0:
             return
         query = self._queries[-1]
@@ -165,9 +161,7 @@ class ClientRuntimeContext(object):
 
     def after_execute(self, action, once=True, *args, **kwargs):
         # type: (Callable[[requests.Response, Any, Any], None], bool, Any, Any) -> Self
-        """
-        Attach an event handler which is triggered after request is submitted to server
-        """
+        """Attach an event handler which is triggered after request is submitted to server"""
 
         def _process_response(response):
             # type: (requests.Response) -> None

office365/runtime/client_value_collection.py

@@ -39,14 +39,9 @@ class ClientValueCollection(ClientValue, Generic[T]):
     def __repr__(self):
         return repr(self._data)
 
-    def __str__(self):
-        return ",".join(self._data)
-
     def to_json(self, json_format=None):
-        # type: (ODataJsonFormat) -> dict
-        """
-        Serializes a client value's collection
-        """
+        # type: (ODataJsonFormat) -> list
+        """Serializes a client value's collection"""
         json = [v for v in self]
         for i, v in enumerate(json):
             if isinstance(v, ClientValue):
@@ -84,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/compat.py

@@ -1,3 +1,5 @@
+# ruff: noqa
+# pylint: skip-file
 import sys
 
 # -------

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/reader.py

@@ -19,7 +19,7 @@ class ODataReader(object):
     def format_file(self):
         import xml.dom.minidom
 
-        with open(self._metadata_path, "r") as in_file:
+        with open(self._metadata_path, "r", encoding="utf8") as in_file:
             metadata_content = in_file.read()
 
         formatted_metadata_content = xml.dom.minidom.parseString(