@backtomyfuture/exchange-cli-win32-x64 0.1.10

package/bin/_internal/exchangelib/services/get_streaming_events.py

@@ -0,0 +1,102 @@
+import logging
+
+from ..errors import EWSError, InvalidTypeError
+from ..properties import Notification
+from ..util import MNS, DocumentYielder, DummyResponse, create_element, get_xml_attr, get_xml_attrs
+from .common import EWSAccountService, add_xml_child
+
+log = logging.getLogger(__name__)
+xml_log = logging.getLogger(f"{__name__}.xml")
+
+
+class GetStreamingEvents(EWSAccountService):
+    """MSDN:
+    https://docs.microsoft.com/en-us/exchange/client-developer/web-service-reference/getstreamingevents-operation
+    """
+
+    SERVICE_NAME = "GetStreamingEvents"
+    element_container_name = f"{{{MNS}}}Notifications"
+    prefer_affinity = True
+
+    # Connection status values
+    OK = "OK"
+    CLOSED = "Closed"
+
+    def __init__(self, *args, **kwargs):
+        # These values are set each time call() is consumed
+        self.connection_status = None
+        super().__init__(*args, **kwargs)
+        self.streaming = True
+
+    def call(self, subscription_ids, connection_timeout):
+        if not isinstance(connection_timeout, int):
+            raise InvalidTypeError("connection_timeout", connection_timeout, int)
+        if connection_timeout < 1:
+            raise ValueError(f"'connection_timeout' {connection_timeout} must be a positive integer")
+        # Add 60 seconds to the timeout, to allow us to always get the final message containing ConnectionStatus=Closed
+        self.timeout = connection_timeout * 60 + 60
+        return self._elems_to_objs(
+            self._get_elements(
+                payload=self.get_payload(
+                    subscription_ids=subscription_ids,
+                    connection_timeout=connection_timeout,
+                )
+            )
+        )
+
+    def _elem_to_obj(self, elem):
+        return Notification.from_xml(elem=elem, account=None)
+
+    @classmethod
+    def _get_soap_parts(cls, response):
+        # Pass the response unaltered. We want to use our custom document yielder
+        return None, response
+
+    def _get_soap_messages(self, body):
+        # 'body' is actually the raw response passed on by '_get_soap_parts'. We want to continuously read the content,
+        # looking for complete XML documents. When we have a full document, we want to parse it as if it was a normal
+        # XML response.
+        r = body
+        for i, doc in enumerate(DocumentYielder(r.iter_content()), start=1):
+            xml_log.debug("Response XML (docs counter: %(i)s): %(xml_response)s", dict(i=i, xml_response=doc))
+            response = DummyResponse(content=doc)
+            try:
+                _, body = super()._get_soap_parts(response=response)
+            except Exception:
+                r.close()  # Release memory
+                raise
+            # TODO: We're skipping ._update_api_version() here because we don't have access to the 'api_version' used.
+            # TODO: We should be doing a lot of error handling for ._get_soap_messages().
+            yield from super()._get_soap_messages(body=body)
+            if self.connection_status == self.CLOSED:
+                # Don't wait for the TCP connection to timeout
+                break
+
+    def _get_element_container(self, message, name=None):
+        error_ids_elem = message.find(f"{{{MNS}}}ErrorSubscriptionIds")
+        error_ids = [] if error_ids_elem is None else get_xml_attrs(error_ids_elem, f"{{{MNS}}}SubscriptionId")
+        self.connection_status = get_xml_attr(message, f"{{{MNS}}}ConnectionStatus")  # Either 'OK' or 'Closed'
+        log.debug("Connection status is: %s", self.connection_status)
+        # Upstream normally expects to find a 'name' tag but our response does not always have it. We still want to
+        # call upstream, to have exceptions raised. Return an empty list if there is no 'name' tag and no errors.
+        if message.find(name) is None:
+            name = None
+        try:
+            res = super()._get_element_container(message=message, name=name)
+        except EWSError as e:
+            # When the request contains a combination of good and failing subscription IDs, notifications for the good
+            # subscriptions seem to never be returned even though the XML spec allows it. This means there's no point in
+            # trying to collect any notifications here and delivering a combination of errors and return values.
+            if error_ids:
+                e.value += f" (subscription IDs: {error_ids})"
+            raise e
+        return [] if name is None else res
+
+    def get_payload(self, subscription_ids, connection_timeout):
+        payload = create_element(f"m:{self.SERVICE_NAME}")
+        subscriptions_elem = create_element("m:SubscriptionIds")
+        for subscription_id in subscription_ids:
+            add_xml_child(subscriptions_elem, "t:SubscriptionId", subscription_id)
+        payload.append(subscriptions_elem)
+        add_xml_child(payload, "m:ConnectionTimeout", connection_timeout)
+        return payload

package/bin/_internal/exchangelib/services/get_user_availability.py

@@ -0,0 +1,67 @@
+from collections import namedtuple
+
+from ..properties import FreeBusyView
+from ..util import MNS, create_element, set_xml_value
+from .common import EWSService
+
+
+class GetUserAvailability(EWSService):
+    """Get detailed availability information for a list of users.
+    MSDN:
+    https://docs.microsoft.com/en-us/exchange/client-developer/web-service-reference/getuseravailability-operation
+    """
+
+    SERVICE_NAME = "GetUserAvailability"
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.tzinfo = None
+
+    def call(self, tzinfo, mailbox_data, timezone, free_busy_view_options):
+        # TODO: Also supports SuggestionsViewOptions, see
+        #  https://docs.microsoft.com/en-us/exchange/client-developer/web-service-reference/suggestionsviewoptions
+        self.tzinfo = tzinfo
+        return self._elems_to_objs(
+            self._chunked_get_elements(
+                self.get_payload,
+                items=mailbox_data,
+                timezone=timezone,
+                free_busy_view_options=free_busy_view_options,
+            )
+        )
+
+    @property
+    def _timezone(self):
+        return self.tzinfo
+
+    def _elem_to_obj(self, elem):
+        fake_account = namedtuple("Account", ["default_timezone"])(default_timezone=self.tzinfo)
+        return FreeBusyView.from_xml(elem=elem, account=fake_account)
+
+    def get_payload(self, mailbox_data, timezone, free_busy_view_options):
+        payload = create_element(f"m:{self.SERVICE_NAME}Request")
+        set_xml_value(payload, timezone, version=self.protocol.version)
+        mailbox_data_array = create_element("m:MailboxDataArray")
+        set_xml_value(mailbox_data_array, mailbox_data, version=self.protocol.version)
+        payload.append(mailbox_data_array)
+        return set_xml_value(payload, free_busy_view_options, version=self.protocol.version)
+
+    @staticmethod
+    def _response_messages_tag():
+        return f"{{{MNS}}}FreeBusyResponseArray"
+
+    @classmethod
+    def _response_message_tag(cls):
+        return f"{{{MNS}}}FreeBusyResponse"
+
+    def _get_elements_in_response(self, response):
+        for msg in response:
+            container_or_exc = self._get_element_container(message=msg.find(f"{{{MNS}}}ResponseMessage"))
+            if isinstance(container_or_exc, Exception):
+                yield container_or_exc
+            else:
+                yield from self._get_elements_in_container(container=msg)
+
+    @classmethod
+    def _get_elements_in_container(cls, container):
+        return [container.find(f"{{{MNS}}}FreeBusyView")]

package/bin/_internal/exchangelib/services/get_user_configuration.py

@@ -0,0 +1,43 @@
+from ..errors import InvalidEnumValue
+from ..properties import UserConfiguration
+from ..util import create_element, set_xml_value
+from .common import EWSAccountService
+
+ID = "Id"
+DICTIONARY = "Dictionary"
+XML_DATA = "XmlData"
+BINARY_DATA = "BinaryData"
+ALL = "All"
+PROPERTIES_CHOICES = (ID, DICTIONARY, XML_DATA, BINARY_DATA, ALL)
+
+
+class GetUserConfiguration(EWSAccountService):
+    """MSDN:
+    https://docs.microsoft.com/en-us/exchange/client-developer/web-service-reference/getuserconfiguration-operation
+    """
+
+    SERVICE_NAME = "GetUserConfiguration"
+
+    def call(self, user_configuration_name, properties):
+        if properties not in PROPERTIES_CHOICES:
+            raise InvalidEnumValue("properties", properties, PROPERTIES_CHOICES)
+        return self._elems_to_objs(
+            self._get_elements(
+                payload=self.get_payload(user_configuration_name=user_configuration_name, properties=properties)
+            )
+        )
+
+    def _elem_to_obj(self, elem):
+        return UserConfiguration.from_xml(elem=elem, account=self.account)
+
+    @classmethod
+    def _get_elements_in_container(cls, container):
+        return container.findall(UserConfiguration.response_tag())
+
+    def get_payload(self, user_configuration_name, properties):
+        payload = create_element(f"m:{self.SERVICE_NAME}")
+        set_xml_value(payload, user_configuration_name, version=self.account.version)
+        payload.append(
+            set_xml_value(create_element("m:UserConfigurationProperties"), properties, version=self.account.version)
+        )
+        return payload

package/bin/_internal/exchangelib/services/get_user_oof_settings.py

@@ -0,0 +1,40 @@
+from ..properties import AvailabilityMailbox
+from ..settings import OofSettings
+from ..util import MNS, TNS, create_element, set_xml_value
+from .common import EWSAccountService
+
+
+class GetUserOofSettings(EWSAccountService):
+    """Get automatic reply settings for the specified mailbox.
+    MSDN: https://docs.microsoft.com/en-us/exchange/client-developer/web-service-reference/getuseroofsettings-operation
+    """
+
+    SERVICE_NAME = "GetUserOofSettings"
+    element_container_name = f"{{{TNS}}}OofSettings"
+
+    def call(self, mailbox):
+        return self._elems_to_objs(self._get_elements(payload=self.get_payload(mailbox=mailbox)))
+
+    def _elem_to_obj(self, elem):
+        return OofSettings.from_xml(elem=elem, account=self.account)
+
+    def get_payload(self, mailbox):
+        return set_xml_value(
+            create_element(f"m:{self.SERVICE_NAME}Request"),
+            AvailabilityMailbox.from_mailbox(mailbox),
+            version=self.account.version,
+        )
+
+    @classmethod
+    def _get_elements_in_container(cls, container):
+        # This service only returns one result, directly in 'container'
+        return [container]
+
+    def _get_element_container(self, message, name=None):
+        # This service returns the result container outside the response message
+        super()._get_element_container(message=message.find(self._response_message_tag()), name=None)
+        return message.find(name)
+
+    @classmethod
+    def _response_message_tag(cls):
+        return f"{{{MNS}}}ResponseMessage"

package/bin/_internal/exchangelib/services/get_user_settings.py

@@ -0,0 +1,87 @@
+import logging
+
+from ..errors import MalformedResponseError
+from ..properties import UserResponse
+from ..transport import DEFAULT_ENCODING
+from ..util import ANS, add_xml_child, create_element, ns_translation, set_xml_value, xml_to_str
+from ..version import EXCHANGE_2010
+from .common import EWSService
+
+log = logging.getLogger(__name__)
+
+
+class GetUserSettings(EWSService):
+    """Take a list of users and requested Autodiscover settings for these users. Returns the requested settings values.
+
+    MSDN:
+    https://learn.microsoft.com/en-us/exchange/client-developer/web-service-reference/getusersettings-operation-soap
+    """
+
+    SERVICE_NAME = "GetUserSettings"
+    NS_MAP = {k: v for k, v in ns_translation.items() if k in ("s", "t", "a", "wsa", "xsi")}
+    element_container_name = f"{{{ANS}}}UserResponses"
+    supported_from = EXCHANGE_2010
+
+    def call(self, users, settings):
+        return self._elems_to_objs(self._get_elements(self.get_payload(users=users, settings=settings)))
+
+    def wrap(self, content, api_version=None):
+        envelope = create_element("s:Envelope", nsmap=self.NS_MAP)
+        header = create_element("s:Header")
+        if api_version:
+            add_xml_child(header, "a:RequestedServerVersion", api_version)
+        action = f"http://schemas.microsoft.com/exchange/2010/Autodiscover/Autodiscover/{self.SERVICE_NAME}"
+        add_xml_child(header, "wsa:Action", action)
+        add_xml_child(header, "wsa:To", self.protocol.service_endpoint)
+        identity = self._account_to_impersonate
+        if identity:
+            add_xml_child(header, "t:ExchangeImpersonation", identity)
+        envelope.append(header)
+        body = create_element("s:Body")
+        body.append(content)
+        envelope.append(body)
+        return xml_to_str(envelope, encoding=DEFAULT_ENCODING, xml_declaration=True)
+
+    def _elem_to_obj(self, elem):
+        return UserResponse.from_xml(elem=elem, account=None)
+
+    def get_payload(self, users, settings):
+        payload = create_element(f"a:{self.SERVICE_NAME}RequestMessage")
+        request = create_element("a:Request")
+        users_elem = create_element("a:Users")
+        for user in users:
+            mailbox = create_element("a:Mailbox")
+            set_xml_value(mailbox, user)
+            add_xml_child(users_elem, "a:User", mailbox)
+        request.append(users_elem)
+        requested_settings = create_element("a:RequestedSettings")
+        for setting in settings:
+            add_xml_child(requested_settings, "a:Setting", UserResponse.SETTINGS_MAP[setting])
+        request.append(requested_settings)
+        payload.append(request)
+        return payload
+
+    @classmethod
+    def _response_tag(cls):
+        """Return the name of the element containing the service response."""
+        return f"{{{ANS}}}{cls.SERVICE_NAME}ResponseMessage"
+
+    def _get_element_container(self, message, name=None):
+        response = message.find(f"{{{ANS}}}Response")
+        # ErrorCode: See
+        # https://learn.microsoft.com/en-us/exchange/client-developer/web-service-reference/errorcode-soap
+        # There are two 'ErrorCode' elements in the response; one is a child of the 'Response' element, the other is a
+        # child of the 'UserResponse' element. Let's handle both with the same code.
+        res = UserResponse.parse_elem(response)
+        if isinstance(res, Exception):
+            raise res
+        if res.error_code == "NoError":
+            container = response.find(name)
+            if container is None:
+                raise MalformedResponseError(f"No {name} elements in ResponseMessage ({xml_to_str(response)})")
+            return container
+        # Raise any non-acceptable errors in the container, or return the acceptable exception instance
+        try:
+            raise self._get_exception(code=res.error_code, text=res.error_message)
+        except self.ERRORS_TO_CATCH_IN_RESPONSE as e:
+            return e

package/bin/_internal/exchangelib/services/inbox_rules.py

@@ -0,0 +1,104 @@
+from typing import Any, Generator, Optional, Union
+
+from ..errors import ErrorInvalidOperation
+from ..properties import CreateRuleOperation, DeleteRuleOperation, InboxRules, Operations, Rule, SetRuleOperation
+from ..util import MNS, add_xml_child, create_element, get_xml_attr, set_xml_value
+from .common import EWSAccountService
+
+
+class GetInboxRules(EWSAccountService):
+    """
+    MSDN: https://docs.microsoft.com/en-us/exchange/client-developer/web-service-reference/getinboxrules-operation
+
+    The GetInboxRules operation uses Exchange Web Services to retrieve Inbox rules in the identified user's mailbox.
+    """
+
+    SERVICE_NAME = "GetInboxRules"
+    element_container_name = InboxRules.response_tag()
+    ERRORS_TO_CATCH_IN_RESPONSE = EWSAccountService.ERRORS_TO_CATCH_IN_RESPONSE + (ErrorInvalidOperation,)
+
+    def call(self, mailbox: Optional[str] = None) -> Generator[Union[Rule, Exception, None], Any, None]:
+        if not mailbox:
+            mailbox = self.account.primary_smtp_address
+        payload = self.get_payload(mailbox=mailbox)
+        elements = self._get_elements(payload=payload)
+        return self._elems_to_objs(elements)
+
+    def _elem_to_obj(self, elem):
+        return Rule.from_xml(elem=elem, account=self.account)
+
+    def get_payload(self, mailbox):
+        payload = create_element(f"m:{self.SERVICE_NAME}")
+        add_xml_child(payload, "m:MailboxSmtpAddress", mailbox)
+        return payload
+
+    def _get_element_container(self, message, name=None):
+        if name:
+            response_class = message.get("ResponseClass")
+            response_code = get_xml_attr(message, f"{{{MNS}}}ResponseCode")
+            if response_class == "Success" and response_code == "NoError" and message.find(name) is None:
+                return []
+        return super()._get_element_container(message, name)
+
+
+class UpdateInboxRules(EWSAccountService):
+    """
+    MSDN: https://docs.microsoft.com/en-us/exchange/client-developer/web-service-reference/updateinboxrules-operation
+
+    The UpdateInboxRules operation updates the authenticated user's Inbox rules by applying the specified operations.
+    UpdateInboxRules is used to create an Inbox rule, to set an Inbox rule, or to delete an Inbox rule.
+
+    When you use the UpdateInboxRules operation, Exchange Web Services deletes client-side send rules.
+    Client-side send rules are stored on the client in the rule Folder Associated Information (FAI) Message and nowhere
+    else. EWS deletes this rule FAI message by default, based on the expectation that Outlook will recreate it.
+    However, Outlook can't recreate rules that don't also exist as an extended rule, and client-side send rules don't
+    exist as extended rules. As a result, these rules are lost. We suggest you consider this when designing your
+    solution.
+    """
+
+    SERVICE_NAME = "UpdateInboxRules"
+    ERRORS_TO_CATCH_IN_RESPONSE = EWSAccountService.ERRORS_TO_CATCH_IN_RESPONSE + (ErrorInvalidOperation,)
+
+    def call(self, rule: Rule, remove_outlook_rule_blob: bool = True):
+        payload = self.get_payload(rule=rule, remove_outlook_rule_blob=remove_outlook_rule_blob)
+        return self._get_elements(payload=payload)
+
+    def _get_operation(self, rule):
+        raise NotImplementedError()
+
+    def get_payload(self, rule: Rule, remove_outlook_rule_blob: bool = True):
+        payload = create_element(f"m:{self.SERVICE_NAME}")
+        add_xml_child(payload, "m:RemoveOutlookRuleBlob", remove_outlook_rule_blob)
+        operations = self._get_operation(rule)
+        set_xml_value(payload, operations, version=self.account.version)
+        return payload
+
+
+class CreateInboxRule(UpdateInboxRules):
+    """
+    MSDN:
+    https://docs.microsoft.com/en-us/exchange/client-developer/web-service-reference/updateinboxrules-operation#updateinboxrules-create-rule-request-example
+    """
+
+    def _get_operation(self, rule):
+        return Operations(create_rule_operation=CreateRuleOperation(rule=rule))
+
+
+class SetInboxRule(UpdateInboxRules):
+    """
+    MSDN:
+    https://learn.microsoft.com/en-us/exchange/client-developer/web-service-reference/updateinboxrules-operation#updateinboxrules-set-rule-request-example
+    """
+
+    def _get_operation(self, rule):
+        return Operations(set_rule_operation=SetRuleOperation(rule=rule))
+
+
+class DeleteInboxRule(UpdateInboxRules):
+    """
+    MSDN:
+    https://learn.microsoft.com/en-us/exchange/client-developer/web-service-reference/updateinboxrules-operation#updateinboxrules-delete-rule-request-example
+    """
+
+    def _get_operation(self, rule):
+        return Operations(delete_rule_operation=DeleteRuleOperation(id=rule.id))

package/bin/_internal/exchangelib/services/mark_as_junk.py

@@ -0,0 +1,27 @@
+from ..properties import MovedItemId
+from ..util import create_element
+from .common import EWSAccountService, item_ids_element
+
+
+class MarkAsJunk(EWSAccountService):
+    """MSDN: https://docs.microsoft.com/en-us/exchange/client-developer/web-service-reference/markasjunk-operation"""
+
+    SERVICE_NAME = "MarkAsJunk"
+
+    def call(self, items, is_junk, move_item):
+        return self._elems_to_objs(
+            self._chunked_get_elements(self.get_payload, items=items, is_junk=is_junk, move_item=move_item)
+        )
+
+    def _elem_to_obj(self, elem):
+        return MovedItemId.id_from_xml(elem)
+
+    @classmethod
+    def _get_elements_in_container(cls, container):
+        return container.findall(MovedItemId.response_tag())
+
+    def get_payload(self, items, is_junk, move_item):
+        # Takes a list of items and returns either success or raises an error message
+        payload = create_element(f"m:{self.SERVICE_NAME}", attrs=dict(IsJunk=is_junk, MoveItem=move_item))
+        payload.append(item_ids_element(items=items, version=self.account.version))
+        return payload

package/bin/_internal/exchangelib/services/move_folder.py

@@ -0,0 +1,27 @@
+from ..errors import InvalidTypeError
+from ..folders import BaseFolder
+from ..properties import FolderId
+from ..util import MNS, create_element
+from .common import EWSAccountService, folder_ids_element
+
+
+class MoveFolder(EWSAccountService):
+    """MSDN: https://docs.microsoft.com/en-us/exchange/client-developer/web-service-reference/movefolder-operation"""
+
+    SERVICE_NAME = "MoveFolder"
+    element_container_name = f"{{{MNS}}}Folders"
+
+    def call(self, folders, to_folder):
+        if not isinstance(to_folder, (BaseFolder, FolderId)):
+            raise InvalidTypeError("to_folder", to_folder, (BaseFolder, FolderId))
+        return self._elems_to_objs(self._chunked_get_elements(self.get_payload, items=folders, to_folder=to_folder))
+
+    def _elem_to_obj(self, elem):
+        return FolderId.from_xml(elem=elem.find(FolderId.response_tag()), account=self.account)
+
+    def get_payload(self, folders, to_folder):
+        # Takes a list of folders and returns their new folder IDs
+        payload = create_element(f"m:{self.SERVICE_NAME}")
+        payload.append(folder_ids_element(folders=[to_folder], version=self.account.version, tag="m:ToFolderId"))
+        payload.append(folder_ids_element(folders=folders, version=self.account.version))
+        return payload

package/bin/_internal/exchangelib/services/move_item.py

@@ -0,0 +1,28 @@
+from ..errors import InvalidTypeError
+from ..folders import BaseFolder
+from ..items import Item
+from ..properties import FolderId
+from ..util import MNS, create_element
+from .common import EWSAccountService, folder_ids_element, item_ids_element
+
+
+class MoveItem(EWSAccountService):
+    """MSDN: https://docs.microsoft.com/en-us/exchange/client-developer/web-service-reference/moveitem-operation"""
+
+    SERVICE_NAME = "MoveItem"
+    element_container_name = f"{{{MNS}}}Items"
+
+    def call(self, items, to_folder):
+        if not isinstance(to_folder, (BaseFolder, FolderId)):
+            raise InvalidTypeError("to_folder", to_folder, (BaseFolder, FolderId))
+        return self._elems_to_objs(self._chunked_get_elements(self.get_payload, items=items, to_folder=to_folder))
+
+    def _elem_to_obj(self, elem):
+        return Item.id_from_xml(elem)
+
+    def get_payload(self, items, to_folder):
+        # Takes a list of items and returns their new item IDs
+        payload = create_element(f"m:{self.SERVICE_NAME}")
+        payload.append(folder_ids_element(folders=[to_folder], version=self.account.version, tag="m:ToFolderId"))
+        payload.append(item_ids_element(items=items, version=self.account.version))
+        return payload

package/bin/_internal/exchangelib/services/resolve_names.py

@@ -0,0 +1,104 @@
+import logging
+import warnings
+
+from ..errors import ErrorNameResolutionMultipleResults, ErrorNameResolutionNoResults, InvalidEnumValue
+from ..items import SEARCH_SCOPE_CHOICES, SHAPE_CHOICES, Contact
+from ..properties import Mailbox
+from ..util import MNS, add_xml_child, create_element
+from ..version import EXCHANGE_2010_SP2
+from .common import EWSService, folder_ids_element
+
+log = logging.getLogger(__name__)
+
+
+class ResolveNames(EWSService):
+    """MSDN: https://docs.microsoft.com/en-us/exchange/client-developer/web-service-reference/resolvenames-operation"""
+
+    SERVICE_NAME = "ResolveNames"
+    element_container_name = f"{{{MNS}}}ResolutionSet"
+    ERRORS_TO_CATCH_IN_RESPONSE = ErrorNameResolutionNoResults
+    WARNINGS_TO_IGNORE_IN_RESPONSE = ErrorNameResolutionMultipleResults
+
+    # According to the 'Remarks' section of the MSDN documentation referenced above, at most 100 candidates are
+    # returned for a lookup.
+    # Note: paging information is returned as attrs on the 'ResolutionSet' element, but this service does not
+    # support the 'IndexedPageItemView' element, so it's not really a paging service.
+    candidates_limit = 100
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.return_full_contact_data = False  # A hack to communicate parsing args to _elems_to_objs()
+
+    def call(
+        self,
+        unresolved_entries,
+        parent_folders=None,
+        return_full_contact_data=False,
+        search_scope=None,
+        contact_data_shape=None,
+    ):
+        if self.chunk_size > 100:
+            raise ValueError(
+                f"Chunk size {self.chunk_size} is too high. {self.SERVICE_NAME} supports returning at most 100 "
+                f"candidates for a lookup",
+            )
+        if search_scope and search_scope not in SEARCH_SCOPE_CHOICES:
+            raise InvalidEnumValue("search_scope", search_scope, SEARCH_SCOPE_CHOICES)
+        if contact_data_shape and contact_data_shape not in SHAPE_CHOICES:
+            raise InvalidEnumValue("contact_data_shape", contact_data_shape, SHAPE_CHOICES)
+        self.return_full_contact_data = return_full_contact_data
+        return self._elems_to_objs(
+            self._chunked_get_elements(
+                self.get_payload,
+                items=unresolved_entries,
+                parent_folders=parent_folders,
+                return_full_contact_data=return_full_contact_data,
+                search_scope=search_scope,
+                contact_data_shape=contact_data_shape,
+            )
+        )
+
+    def _get_element_container(self, message, name=None):
+        container_or_exc = super()._get_element_container(message=message, name=name)
+        if isinstance(container_or_exc, Exception):
+            return container_or_exc
+        is_last_page = container_or_exc.get("IncludesLastItemInRange").lower() in ("true", "0")
+        log.debug("Includes last item in range: %s", is_last_page)
+        if not is_last_page:
+            warnings.warn(
+                f"The {self.__class__.__name__} service returns at most {self.candidates_limit} candidates and does "
+                f"not support paging. You have reached this limit and have not received the exhaustive list of "
+                f"candidates."
+            )
+        return container_or_exc
+
+    def _elem_to_obj(self, elem):
+        if self.return_full_contact_data:
+            mailbox_elem = elem.find(Mailbox.response_tag())
+            contact_elem = elem.find(Contact.response_tag())
+            return (
+                None if mailbox_elem is None else Mailbox.from_xml(elem=mailbox_elem, account=None),
+                None if contact_elem is None else Contact.from_xml(elem=contact_elem, account=None),
+            )
+        return Mailbox.from_xml(elem=elem.find(Mailbox.response_tag()), account=None)
+
+    def get_payload(
+        self, unresolved_entries, parent_folders, return_full_contact_data, search_scope, contact_data_shape
+    ):
+        attrs = dict(ReturnFullContactData=return_full_contact_data)
+        if search_scope:
+            attrs["SearchScope"] = search_scope
+        if contact_data_shape:
+            if self.protocol.version.build < EXCHANGE_2010_SP2:
+                raise NotImplementedError(
+                    "'contact_data_shape' is only supported for Exchange 2010 SP2 servers and later"
+                )
+            attrs["ContactDataShape"] = contact_data_shape
+        payload = create_element(f"m:{self.SERVICE_NAME}", attrs=attrs)
+        if parent_folders:
+            payload.append(
+                folder_ids_element(folders=parent_folders, version=self.protocol.version, tag="m:ParentFolderIds")
+            )
+        for entry in unresolved_entries:
+            add_xml_child(payload, "m:UnresolvedEntry", entry)
+        return payload

package/bin/_internal/exchangelib/services/send_item.py

@@ -0,0 +1,26 @@
+from ..errors import InvalidTypeError
+from ..folders import BaseFolder
+from ..properties import FolderId
+from ..util import create_element
+from .common import EWSAccountService, folder_ids_element, item_ids_element
+
+
+class SendItem(EWSAccountService):
+    """MSDN: https://docs.microsoft.com/en-us/exchange/client-developer/web-service-reference/senditem-operation"""
+
+    SERVICE_NAME = "SendItem"
+    returns_elements = False
+
+    def call(self, items, saved_item_folder):
+        if saved_item_folder and not isinstance(saved_item_folder, (BaseFolder, FolderId)):
+            raise InvalidTypeError("saved_item_folder", saved_item_folder, (BaseFolder, FolderId))
+        return self._chunked_get_elements(self.get_payload, items=items, saved_item_folder=saved_item_folder)
+
+    def get_payload(self, items, saved_item_folder):
+        payload = create_element(f"m:{self.SERVICE_NAME}", attrs=dict(SaveItemToFolder=bool(saved_item_folder)))
+        payload.append(item_ids_element(items=items, version=self.account.version))
+        if saved_item_folder:
+            payload.append(
+                folder_ids_element(folders=[saved_item_folder], version=self.account.version, tag="m:SavedItemFolderId")
+            )
+        return payload