Office365-REST-Python-Client 3.1.0__py3-none-any.whl → 3.2.0__py3-none-any.whl

office365/sharepoint/client_context.py

@@ -20,6 +20,7 @@ from office365.runtime.odata.v3.batch_request import DEFAULT_MAX_BATCH_BYTES, OD
 from office365.runtime.odata.v3.json_light_format import JsonLightFormat
 from office365.runtime.paths.resource_path import ResourcePath
 from office365.runtime.types.collections import StringCollection
+from office365.sharepoint.exceptions import SecurityValidationException
 from office365.sharepoint.portal.groups.creation_params import GroupCreationParams
 from office365.sharepoint.portal.groups.site_info import GroupSiteInfo
 from office365.sharepoint.portal.sites.creation_response import SPSiteCreationResponse
@@ -35,6 +36,7 @@ from office365.sharepoint.sites.site import Site
 from office365.sharepoint.tenant.administration.hubsites.collection import (
     HubSiteCollection,
 )
+from office365.sharepoint.thresholds import Limits, limit
 from office365.sharepoint.ui.applicationpages.peoplepicker.web_service_interface import (
     ClientPeoplePickerWebServiceInterface,
     PeoplePickerWebServiceInterface,
@@ -209,20 +211,18 @@ class ClientContext(ClientRuntimeContext):
         return self
 
     def with_user_credentials(self, username: str, password: str) -> Self:
-        """Initializes a client to acquire a token via user credentials.
+        """Initializes a client to acquire a token via user credentials (NTLM).
+
+        Only for **on-premises** SharePoint — construct the context with
+        ``ClientContext(url, allow_ntlm=True)``. For SharePoint Online this raises:
+        the legacy SAML/ACS flow is retired, use :meth:`with_username_and_password`.
 
         Args:
-            username (str): Typically, a UPN in the form of an email address
-            password (str): The password Note: This method uses the legacy SAML/ACS auth flow which Microsoft has
-                retired for SharePoint Online. Use with_username_and_password instead.
-                For on-premises SharePoint, use allow_ntlm=True.
+            username (str): A UPN, or ``DOMAIN\\user`` for NTLM
+            password (str): The password
         """
-        raise RuntimeError(
-            "with_user_credentials uses the legacy SAML/ACS auth flow which "
-            "Microsoft has retired for SharePoint Online. "
-            "Use with_username_and_password(tenant, client_id, username, password) instead. "
-            "For on-premises SharePoint, use allow_ntlm=True."
-        )
+        self.authentication_context.with_credentials(UserCredential(username, password))
+        return self
 
     def with_username_and_password(self, tenant: str, client_id: str, username: str, password: str) -> Self:
         """Initializes a client to acquire a token via Username and password authentication flow.
@@ -268,9 +268,10 @@ class ClientContext(ClientRuntimeContext):
         self.authentication_context.with_credentials(credentials)
         return self
 
+    @limit(Limits.BATCH_ITEMS, arg="items_per_batch")
     def execute_batch(
         self,
-        items_per_batch: int = 100,
+        items_per_batch: int = Limits.BATCH_ITEMS.value,
         success_callback: Optional[Callable[[List[ClientObject | ClientResult]], None]] = None,
         concurrency: int = 1,
         max_batch_bytes: Optional[int] = None,
@@ -283,7 +284,7 @@ class ClientContext(ClientRuntimeContext):
         Throttled sub-requests (HTTP 429/503) are retried individually, honoring
         ``Retry-After`` — only the failed sub-requests are re-sent, so successful
         writes aren't re-applied. ``success_callback`` runs on the caller thread
-        in completion order (not submission order).
+        as each batch completes (completion order when concurrent).
 
         Args:
             items_per_batch (int): Maximum to be selected for bulk operation
@@ -292,27 +293,41 @@ class ClientContext(ClientRuntimeContext):
             max_batch_bytes (int or None): Maximum estimated batch payload size (default ~1 MB)
         """
         max_bytes = DEFAULT_MAX_BATCH_BYTES if max_batch_bytes is None else max_batch_bytes
+        request = self.pending_request()
+        request.warm_up()  # fetch the form digest once before dispatching any batch
         batches = self._split_batches(items_per_batch, max_bytes)
         if concurrency <= 1:
-            batch_request = ODataBatchV3Request(self._base_url, JsonLightFormat())
-            batch_request.beforeExecute += self.authentication_context.authenticate_request
-            batch_request.beforeExecute += self.pending_request().ensure_form_digest
+            batch_request = ODataBatchV3Request(
+                self._base_url, JsonLightFormat(), transport=self.pending_request().transport
+            )
+            batch_request.beforeExecute += request._authenticate_request
+            batch_request.beforeExecute += request.ensure_form_digest
             for qry in batches:
-                batch_request.execute_query_with_retry(qry)
-                if callable(success_callback) and qry.return_type is not None:
-                    success_callback(qry.return_type)
+                self._run_batch(batch_request, qry)
+                if callable(success_callback):
+                    success_callback(qry.return_types)
             return self
 
-        self.pending_request()
         self._execute_batches_in_parallel(batches, concurrency, success_callback)
         return self
 
+    def _run_batch(self, batch_request: ODataBatchV3Request, batch_qry: "BatchQuery") -> None:
+        """Execute one batch, refreshing an expired form digest once and retrying."""
+        try:
+            batch_request.execute_query_with_retry(batch_qry)
+        except SecurityValidationException:
+            self.pending_request().invalidate_digest()
+            self.pending_request().warm_up()
+            batch_request.execute_query_with_retry(batch_qry)
+
     def _execute_batch(self, batch_qry: "BatchQuery") -> list[Any]:
         """Execute a single batch unit on a worker thread (with per-request retry)."""
-        batch_request = ODataBatchV3Request(self._base_url, JsonLightFormat())
-        batch_request.beforeExecute += self.authentication_context.authenticate_request
+        batch_request = ODataBatchV3Request(
+            self._base_url, JsonLightFormat(), transport=self.pending_request().transport
+        )
+        batch_request.beforeExecute += self.pending_request()._authenticate_request
         batch_request.beforeExecute += self.pending_request().ensure_form_digest
-        batch_request.execute_query_with_retry(batch_qry)
+        self._run_batch(batch_request, batch_qry)
         return batch_qry.return_types
 
     def pending_request(self) -> SharePointRequest:
@@ -321,6 +336,8 @@ class ClientContext(ClientRuntimeContext):
             self._pending_request = SharePointRequest(
                 base_url=self._base_url,
                 environment=self._environment,
+                allow_ntlm=self._allow_ntlm,
+                browser_mode=self._browser_mode,
                 authority=self._authority,
             )
         return self._pending_request  # type: ignore[return-value]

office365/sharepoint/clientsidecomponent/hostedapps/app.py

@@ -1,3 +1,6 @@
+from typing_extensions import Self
+
+from office365.runtime.queries.service_operation import ServiceOperationQuery
 from office365.sharepoint.entity import Entity
 
 
@@ -5,3 +8,21 @@ class HostedApp(Entity):
     @property
     def entity_type_name(self):
         return "Microsoft.SharePoint.ClientSideComponent.HostedApp"
+
+    def delete(self) -> Self:
+        """Delete operation."""
+        qry = ServiceOperationQuery(self, "Delete", None, {}, None, None)
+        self.context.add_query(qry)
+        return self
+
+    def update_web_part_data(self, web_part_data_as_json: str) -> Self:
+        """UpdateWebPartData operation.
+
+        Args:
+            web_part_data_as_json (str): webPartDataAsJson parameter
+        """
+        qry = ServiceOperationQuery(
+            self, "UpdateWebPartData", None, {"webPartDataAsJson": web_part_data_as_json}, None, None
+        )
+        self.context.add_query(qry)
+        return self

office365/sharepoint/clientsidecomponent/hostedapps/manager.py

@@ -1,4 +1,6 @@
+from office365.runtime.client_result import ClientResult
 from office365.runtime.paths.service_operation import ServiceOperationPath
+from office365.runtime.queries.service_operation import ServiceOperationQuery
 from office365.sharepoint.clientsidecomponent.hostedapps.app import HostedApp
 from office365.sharepoint.entity import Entity
 
@@ -17,3 +19,17 @@ class HostedAppsManager(Entity):
     @property
     def entity_type_name(self):
         return "Microsoft.SharePoint.ClientSideComponent.HostedAppsManager"
+
+    def add(self, web_part_data_as_json: str, host_type: str) -> ClientResult[int]:
+        """Add operation.
+
+        Args:
+            web_part_data_as_json (str): webPartDataAsJson parameter
+            host_type (str): hostType parameter
+        """
+        return_type = ClientResult(self.context, int())
+        qry = ServiceOperationQuery(
+            self, "Add", None, {"webPartDataAsJson": web_part_data_as_json, "hostType": host_type}, None, return_type
+        )
+        self.context.add_query(qry)
+        return return_type

office365/sharepoint/comments/comment.py

@@ -1,11 +1,19 @@
+from datetime import datetime
+from typing import Optional
+from uuid import UUID
+
 from typing_extensions import Self
 
+from office365.runtime.client_value_collection import ClientValueCollection
 from office365.runtime.paths.resource_path import ResourcePath
 from office365.runtime.queries.service_operation import ServiceOperationQuery
 from office365.runtime.types.odata_property import odata
+from office365.sharepoint.comments.client.identity import Identity
+from office365.sharepoint.comments.contentanchor import ContentAnchor
 from office365.sharepoint.entity import Entity
 from office365.sharepoint.entity_collection import EntityCollection
 from office365.sharepoint.likes.user_entity import UserEntity
+from office365.sharepoint.sharing.principal import Principal
 
 
 class Comment(Entity):
@@ -33,10 +41,84 @@ class Comment(Entity):
         for the same user in the set.
         """
         return self.properties.get(
-            "likedBy",
-            EntityCollection(self.context, UserEntity, ResourcePath("likedBy", self.resource_path)),
+            "likedBy", EntityCollection(self.context, UserEntity, ResourcePath("likedBy", self.resource_path))
         )
 
     @property
     def entity_type_name(self) -> str:
         return "Microsoft.SharePoint.Comments.comment"
+
+    @property
+    def author(self) -> Principal:
+        """Gets the author property"""
+        return self.properties.get("author", Principal())
+
+    @property
+    def content_anchor(self) -> ContentAnchor:
+        """Gets the contentAnchor property"""
+        return self.properties.get("contentAnchor", ContentAnchor())
+
+    @property
+    def created_date(self) -> Optional[datetime]:
+        """Gets the createdDate property"""
+        return self.properties.get("createdDate", datetime.min)
+
+    @property
+    def id_(self) -> Optional[str]:
+        """Gets the id property"""
+        return self.properties.get("id", None)
+
+    @property
+    def is_liked_by_user(self) -> Optional[bool]:
+        """Gets the isLikedByUser property"""
+        return self.properties.get("isLikedByUser", None)
+
+    @property
+    def is_reply(self) -> Optional[bool]:
+        """Gets the isReply property"""
+        return self.properties.get("isReply", None)
+
+    @property
+    def item_id(self) -> Optional[int]:
+        """Gets the itemId property"""
+        return self.properties.get("itemId", None)
+
+    @property
+    def like_count(self) -> Optional[int]:
+        """Gets the likeCount property"""
+        return self.properties.get("likeCount", None)
+
+    @property
+    def list_id(self) -> Optional[UUID]:
+        """Gets the listId property"""
+        return self.properties.get("listId", None)
+
+    @property
+    def mentions(self) -> ClientValueCollection[Identity]:
+        """Gets the mentions property"""
+        return self.properties.get("mentions", ClientValueCollection[Identity](Identity))
+
+    @property
+    def modified_date(self) -> Optional[datetime]:
+        """Gets the modifiedDate property"""
+        return self.properties.get("modifiedDate", datetime.min)
+
+    @property
+    def parent_id(self) -> Optional[str]:
+        """Gets the parentId property"""
+        return self.properties.get("parentId", None)
+
+    @property
+    def relative_created_date(self) -> Optional[str]:
+        """Gets the relativeCreatedDate property"""
+        return self.properties.get("relativeCreatedDate", None)
+
+    @property
+    def reply_count(self) -> Optional[int]:
+        """Gets the replyCount property"""
+        return self.properties.get("replyCount", None)
+
+    @property
+    def text(self) -> Optional[str]:
+        """Gets the text property"""
+        return self.properties.get("text", None)

office365/sharepoint/contentcenter/machinelearning/models/model.py

@@ -5,9 +5,7 @@ from uuid import UUID
 from typing_extensions import Self
 
 from office365.runtime.client_result import ClientResult
-from office365.runtime.queries.function import FunctionQuery
 from office365.runtime.queries.service_operation import ServiceOperationQuery
-from office365.runtime.types.collections import StringCollection
 from office365.sharepoint.contentcenter.machinelearning.modeldependencies import SPModelDependencies
 from office365.sharepoint.contentcenter.machinelearning.modelpublishconfig import SPModelPublishConfig
 from office365.sharepoint.entity import Entity
@@ -240,24 +238,3 @@ class SPMachineLearningModel(Entity):
         qry = ServiceOperationQuery(self, "UpdateModelTypeSpecificSettings", None, {"Settings": settings}, None)
         self.context.add_query(qry)
         return self
-
-    def get_extractor_names(self, package_name: str) -> ClientResult[StringCollection]:
-        """GetExtractorNames operation.
-
-        Args:
-            package_name (str): packageName parameter
-        """
-        return_type = ClientResult(self.context, StringCollection())
-        qry = FunctionQuery(self, "GetExtractorNames", [package_name], return_type)
-        self.context.add_query(qry)
-        return return_type
-
-    def unbind_model_from_content_type(self, content_type_id: str) -> Self:
-        """UnbindModelFromContentType operation.
-
-        Args:
-            content_type_id (str): contentTypeId parameter
-        """
-        qry = ServiceOperationQuery(self, "UnbindModelFromContentType", None, {"contentTypeId": content_type_id}, None)
-        self.context.add_query(qry)
-        return self

office365/sharepoint/contentcenter/machinelearning/publications/publication.py

@@ -4,8 +4,6 @@ from uuid import UUID
 
 from typing_extensions import Self
 
-from office365.runtime.client_result import ClientResult
-from office365.runtime.queries.function import FunctionQuery
 from office365.runtime.queries.service_operation import ServiceOperationQuery
 from office365.sharepoint.entity import Entity
 
@@ -175,10 +173,3 @@ class SPMachineLearningPublication(Entity):
         qry = ServiceOperationQuery(self, "Delete")
         self.context.add_query(qry)
         return self
-
-    def check_tenant_publish_permissions(self) -> ClientResult[bool]:
-        """CheckTenantPublishPermissions operation."""
-        return_type = ClientResult(self.context, bool())
-        qry = FunctionQuery(self, "CheckTenantPublishPermissions", [], return_type)
-        self.context.add_query(qry)
-        return return_type

office365/sharepoint/contentcenter/machinelearning/samples/sample.py

@@ -2,10 +2,7 @@ from datetime import datetime
 from typing import Optional
 from uuid import UUID
 
-from office365.runtime.client_result import ClientResult
 from office365.runtime.client_value_collection import ClientValueCollection
-from office365.runtime.queries.function import FunctionQuery
-from office365.runtime.types.collections import StringCollection
 from office365.sharepoint.entity import Entity
 
 
@@ -128,14 +125,3 @@ class SPMachineLearningSample(Entity):
     def unique_id(self) -> Optional[UUID]:
         """Gets the UniqueId property"""
         return self.properties.get("UniqueId", None)
-
-    def get_template_by_model_id(self, model_id: int) -> ClientResult[StringCollection]:
-        """GetTemplateByModelId operation.
-
-        Args:
-            model_id (int): modelID parameter
-        """
-        return_type = ClientResult(self.context, StringCollection())
-        qry = FunctionQuery(self, "GetTemplateByModelId", [model_id], return_type)
-        self.context.add_query(qry)
-        return return_type

office365/sharepoint/contentcenter/machinelearning/workitems/item.py

@@ -2,23 +2,6 @@ from datetime import datetime
 from typing import Optional
 from uuid import UUID
 
-from office365.runtime.client_result import ClientResult
-from office365.runtime.queries.service_operation import ServiceOperationQuery
-from office365.sharepoint.contentcenter.machinelearning.column_autofill_preview_data import (
-    SPMachineLearningColumnAutofillPreviewData,
-)
-from office365.sharepoint.contentcenter.machinelearning.column_autofill_preview_result import (
-    SPMachineLearningColumnAutofillPreviewResult,
-)
-from office365.sharepoint.contentcenter.machinelearning.list_autofill_entity_data import (
-    SPMachineLearningListAutofillEntityData,
-)
-from office365.sharepoint.contentcenter.machinelearning.list_autofill_item_results import (
-    SPMachineLearningListAutofillItemResults,
-)
-from office365.sharepoint.contentcenter.machinelearning.sp_machine_learning_doc_lib_autofill_item_results import (
-    SPMachineLearningDocLibAutofillItemResults,
-)
 from office365.sharepoint.entity import Entity
 
 
@@ -91,66 +74,3 @@ class SPMachineLearningWorkItem(Entity):
     def type_(self) -> Optional[UUID]:
         """Gets the Type property"""
         return self.properties.get("Type", None)
-
-    def autofill_doc_lib_synchronous(
-        self, parameters: SPMachineLearningListAutofillEntityData
-    ) -> ClientResult[SPMachineLearningDocLibAutofillItemResults]:
-        """AutofillDocLibSynchronous operation.
-
-        Args:
-            parameters (SPMachineLearningListAutofillEntityData): parameters parameter
-        """
-        return_type = ClientResult(self.context, SPMachineLearningDocLibAutofillItemResults())
-        qry = ServiceOperationQuery(
-            self, "AutofillDocLibSynchronous", None, {"parameters": parameters}, None, return_type
-        )
-        self.context.add_query(qry)
-        return return_type
-
-    def autofill_list_synchronous(
-        self, parameters: SPMachineLearningListAutofillEntityData
-    ) -> ClientResult[SPMachineLearningListAutofillItemResults]:
-        """AutofillListSynchronous operation.
-
-        Args:
-            parameters (SPMachineLearningListAutofillEntityData): parameters parameter
-        """
-        return_type = ClientResult(self.context, SPMachineLearningListAutofillItemResults())
-        qry = ServiceOperationQuery(self, "AutofillListSynchronous", None, {"parameters": parameters}, None, return_type)
-        self.context.add_query(qry)
-        return return_type
-
-    def autofill_test_prompt(
-        self, parameters: SPMachineLearningColumnAutofillPreviewData
-    ) -> ClientResult[SPMachineLearningColumnAutofillPreviewResult]:
-        """AutofillTestPrompt operation.
-
-        Args:
-            parameters (SPMachineLearningColumnAutofillPreviewData): parameters parameter
-        """
-        return_type = ClientResult(self.context, SPMachineLearningColumnAutofillPreviewResult())
-        qry = ServiceOperationQuery(self, "AutofillTestPrompt", None, {"parameters": parameters}, None, return_type)
-        self.context.add_query(qry)
-        return return_type
-
-    def create_doc_lib_autofill(self, parameters: SPMachineLearningListAutofillEntityData) -> ClientResult[str]:
-        """CreateDocLibAutofill operation.
-
-        Args:
-            parameters (SPMachineLearningListAutofillEntityData): parameters parameter
-        """
-        return_type = ClientResult(self.context, str())
-        qry = ServiceOperationQuery(self, "CreateDocLibAutofill", None, {"parameters": parameters}, None, return_type)
-        self.context.add_query(qry)
-        return return_type
-
-    def create_list_autofill(self, parameters: SPMachineLearningListAutofillEntityData) -> ClientResult[str]:
-        """CreateListAutofill operation.
-
-        Args:
-            parameters (SPMachineLearningListAutofillEntityData): parameters parameter
-        """
-        return_type = ClientResult(self.context, str())
-        qry = ServiceOperationQuery(self, "CreateListAutofill", None, {"parameters": parameters}, None, return_type)
-        self.context.add_query(qry)
-        return return_type

office365/sharepoint/contentsolution/template_api.py

@@ -0,0 +1,148 @@
+from __future__ import annotations
+
+from uuid import UUID
+
+from typing_extensions import Self
+
+from office365.runtime.client_result import ClientResult
+from office365.runtime.client_value_collection import ClientValueCollection
+from office365.runtime.queries.function import FunctionQuery
+from office365.runtime.queries.service_operation import ServiceOperationQuery
+from office365.sharepoint.contentsolution.add_template_fields_request import AddTemplateFieldsRequest
+from office365.sharepoint.contentsolution.content_control_std_content import ContentControlStdContent
+from office365.sharepoint.contentsolution.create_template_request import CreateTemplateRequest
+from office365.sharepoint.contentsolution.document_field import DocumentField
+from office365.sharepoint.contentsolution.field_input import FieldInput
+from office365.sharepoint.contentsolution.template import Template
+from office365.sharepoint.contentsolution.update_template_field_request import UpdateTemplateFieldRequest
+from office365.sharepoint.entity import Entity
+
+
+class TemplateAPI(Entity):
+    def add_fields(self, request: AddTemplateFieldsRequest) -> ClientResult[ClientValueCollection[DocumentField]]:
+        """addFields operation.
+
+        Args:
+            request (AddTemplateFieldsRequest): request parameter
+        """
+        return_type = ClientResult(self.context, ClientValueCollection[DocumentField]())
+        qry = ServiceOperationQuery(self, "addFields", None, {"request": request}, None, return_type)
+        self.context.add_query(qry)
+        return return_type
+
+    def create_document(self) -> Self:
+        """createDocument operation."""
+        qry = ServiceOperationQuery(self, "createDocument", None, {}, None, None)
+        self.context.add_query(qry)
+        return self
+
+    def create_template(self, request: CreateTemplateRequest) -> ClientResult[Template]:
+        """createTemplate operation.
+
+        Args:
+            request (CreateTemplateRequest): request parameter
+        """
+        return_type = ClientResult(self.context, Template())
+        qry = ServiceOperationQuery(self, "createTemplate", None, {"request": request}, None, return_type)
+        self.context.add_query(qry)
+        return return_type
+
+    def create_template_using_stream(
+        self,
+        document_folder_id: int,
+        document_library_id: UUID,
+        document_site_id: UUID,
+        document_web_id: UUID,
+        fields: ClientValueCollection[FieldInput],
+        form_id: str,
+        template_name: str,
+        content_stream: bytes,
+    ) -> ClientResult[Template]:
+        """CreateTemplateUsingStream operation.
+
+        Args:
+            document_folder_id (int): DocumentFolderId parameter
+            document_library_id (UUID): DocumentLibraryId parameter
+            document_site_id (UUID): DocumentSiteId parameter
+            document_web_id (UUID): DocumentWebId parameter
+            fields (ClientValueCollection[FieldInput]): Fields parameter
+            form_id (str): FormId parameter
+            template_name (str): TemplateName parameter
+            content_stream (bytes): contentStream parameter
+        """
+        return_type = ClientResult(self.context, Template())
+        qry = ServiceOperationQuery(
+            self,
+            "CreateTemplateUsingStream",
+            None,
+            {
+                "DocumentFolderId": document_folder_id,
+                "DocumentLibraryId": document_library_id,
+                "DocumentSiteId": document_site_id,
+                "DocumentWebId": document_web_id,
+                "Fields": fields,
+                "FormId": form_id,
+                "TemplateName": template_name,
+                "contentStream": content_stream,
+            },
+            None,
+            return_type,
+        )
+        self.context.add_query(qry)
+        return return_type
+
+    def get_content_control_standard_content(
+        self, template_id: UUID, fetch_conditionals_only: bool
+    ) -> ClientResult[ClientValueCollection[ContentControlStdContent]]:
+        """getContentControlStandardContent operation.
+
+        Args:
+            template_id (UUID): templateId parameter
+            fetch_conditionals_only (bool): fetchConditionalsOnly parameter
+        """
+        return_type = ClientResult(self.context, ClientValueCollection[ContentControlStdContent]())
+        qry = FunctionQuery(
+            self, "getContentControlStandardContent", [template_id, fetch_conditionals_only], return_type
+        )
+        self.context.add_query(qry)
+        return return_type
+
+    def get_fields(self, template_id: UUID, version_type: int) -> ClientResult[ClientValueCollection[DocumentField]]:
+        """getFields operation.
+
+        Args:
+            template_id (UUID): templateId parameter
+            version_type (int): versionType parameter
+        """
+        return_type = ClientResult(self.context, ClientValueCollection[DocumentField]())
+        qry = FunctionQuery(self, "getFields", [template_id, version_type], return_type)
+        self.context.add_query(qry)
+        return return_type
+
+    def get_template(self, template_id: UUID) -> ClientResult[Template]:
+        """getTemplate operation.
+
+        Args:
+            template_id (UUID): templateId parameter
+        """
+        return_type = ClientResult(self.context, Template())
+        qry = FunctionQuery(self, "getTemplate", [template_id], return_type)
+        self.context.add_query(qry)
+        return return_type
+
+    def publish_template(self) -> Self:
+        """publishTemplate operation."""
+        qry = ServiceOperationQuery(self, "publishTemplate", None, {}, None, None)
+        self.context.add_query(qry)
+        return self
+
+    def update_field(self, request: UpdateTemplateFieldRequest) -> ClientResult[DocumentField]:
+        """updateField operation.
+
+        Args:
+            request (UpdateTemplateFieldRequest): request parameter
+        """
+        return_type = ClientResult(self.context, DocumentField())
+        qry = ServiceOperationQuery(self, "updateField", None, {"request": request}, None, return_type)
+        self.context.add_query(qry)
+        return return_type

office365/sharepoint/contenttypes/collection.py

@@ -2,7 +2,6 @@ from __future__ import annotations
 
 from typing import Dict, Optional, cast
 
-from office365.runtime.client_request_exception import ClientRequestException, DuplicatedObjectException
 from office365.runtime.paths.service_operation import ServiceOperationPath
 from office365.runtime.queries.create_entity import CreateEntityQuery
 from office365.runtime.queries.service_operation import ServiceOperationQuery
@@ -41,17 +40,40 @@ class ContentTypeCollection(EntityCollection[ContentType]):
             self,
         )
 
-    def ensure(self, name: str, description: str | None = None, group: str | None = None) -> ContentType:
-        """Ensure a content type with the given name exists (idempotent)."""
-        info = ContentTypeCreationInformation(name, description, group)
-        return_type = self.add(info)
+    def ensure(
+        self,
+        name: str,
+        description: str | None = None,
+        group: str | None = None,
+        *,
+        on_conflict: str = "skip",
+    ) -> ContentType:
+        """Ensure a content type with the given name exists (idempotent).
 
-        def _on_error(error: ClientRequestException):
-            if not isinstance(error, DuplicatedObjectException):
-                raise error
-            self.get_by_name(name).after_execute(lambda existing: return_type.copy_from(existing), execute_first=True)
+        With ``on_conflict="update"`` the existing content type's description and
+        group are reconciled.
+        """
+        from office365.runtime.queries.get_or_create import create_or_get
+
+        info = ContentTypeCreationInformation(name, description, group)
 
-        return return_type.on_error(_on_error)
+        def _reconcile(content_type: ContentType) -> None:
+            changed = False
+            if description is not None and content_type.description != description:
+                content_type.set_property("Description", description)
+                changed = True
+            if group is not None and content_type.group != group:
+                content_type.set_property("Group", group)
+                changed = True
+            if changed:
+                content_type.update()
+
+        return create_or_get(
+            create=lambda: self.add(info),
+            find=lambda: self.get_by_name(name),
+            on_conflict=on_conflict,
+            reconcile=_reconcile,
+        )
 
     def add(self, content_type_info: ContentTypeCreationInformation) -> ContentType:
         """Adds a new content type to the collection and returns a reference to the added SP.ContentType.