chore: Fix some Deepsource suggestions

Author: Erik Cederstrand

exchangelib/autodiscover/cache.py

@@ -116,9 +116,8 @@ def __delitem__(self, key):
         # Empty both local and persistent cache. Don't fail on non-existing entries because we could end here
         # multiple times due to race conditions.
         domain = key[0]
-        with shelve_open_with_failover(self._storage_file) as db:
-            with suppress(KeyError):
-                del db[str(domain)]
+        with shelve_open_with_failover(self._storage_file) as db, suppress(KeyError):
+            del db[str(domain)]
         with suppress(KeyError):
             del self._protocols[key]
 

exchangelib/credentials.py

@@ -166,7 +166,8 @@ def session_params(self):
             )
         return res
 
-    def token_params(self):
+    @staticmethod
+    def token_params():
         """Extra parameters when requesting the token"""
         return {"include_client_id": True}
 

exchangelib/fields.py

@@ -293,7 +293,6 @@ def __init__(
         is_searchable=True,
         is_attribute=False,
         default=None,
-        *args,
         **kwargs,
     ):
         self.name = name  # Usually set by the EWSMeta metaclass
@@ -310,7 +309,7 @@ def __init__(
         self.is_searchable = is_searchable
         # When true, this field is treated as an XML attribute instead of an element
         self.is_attribute = is_attribute
-        super().__init__(*args, **kwargs)
+        super().__init__(**kwargs)
 
     def clean(self, value, version=None):
         if version and not self.supports_version(version):

exchangelib/folders/collections.py

@@ -91,7 +91,7 @@ def exclude(self, *args, **kwargs):
     def people(self):
         return QuerySet(self).people()
 
-    def view(self, start, end, max_items=None, *args, **kwargs):
+    def view(self, start, end, max_items=None):
         """Implement the CalendarView option to FindItem. The difference between 'filter' and 'view' is that 'filter'
         only returns the master CalendarItem for recurring items, while 'view' unfolds recurring items and returns all
         CalendarItem occurrences as one would normally expect when presenting a calendar.
@@ -109,7 +109,7 @@ def view(self, start, end, max_items=None, *args, **kwargs):
         :param max_items:  (Default value = None)
         :return:
         """
-        qs = QuerySet(self).filter(*args, **kwargs)
+        qs = QuerySet(self)
         qs.calendar_view = CalendarView(start=start, end=end, max_items=max_items)
         return qs
 

exchangelib/services/common.py

@@ -221,6 +221,7 @@ def _elems_to_objs(self, elems):
             yield self._elem_to_obj(elem)
 
     def _elem_to_obj(self, elem):
+        """Convert a single XML element to a single Python object"""
         if not self.returns_elements:
             raise RuntimeError("Incorrect call to method when 'returns_elements' is False")
         raise NotImplementedError()
@@ -335,7 +336,7 @@ def _get_elements(self, payload):
                     self.stop_streaming()
 
     def _handle_response_cookies(self, session):
-        pass
+        """Code to react on response cookies"""
 
     def _get_response(self, payload, api_version):
         """Send the actual HTTP request and get the response."""
@@ -375,13 +376,13 @@ def _api_versions_to_try(self):
             v for v in self.supported_api_versions() if v != self._version_hint.api_version
         )
 
-    def _get_response_xml(self, payload, **parse_opts):
+    def _get_response_xml(self, payload):
         """Send the payload to the server and return relevant elements from the result. Several things happen here:
-          * The payload is wrapped in SOAP headers and sent to the server
-          * The Exchange API version is negotiated and stored in the protocol object
-          * Connection errors are handled and possibly reraised as ErrorServerBusy
-          * SOAP errors are raised
-          * EWS errors are raised, or passed on to the caller
+          * Wraps the payload is wrapped in SOAP headers and sends to the server
+          * Negotiates the Exchange API version and stores it in the protocol object
+          * Handles connection errors and possibly re-raises them as ErrorServerBusy
+          * Raises SOAP errors
+          * Raises EWS errors or passes them on to the caller
 
         :param payload: The request payload, as an XML object
         :return: A generator of XML objects or None if the service does not return a result
@@ -397,15 +398,15 @@ def _get_response_xml(self, payload, **parse_opts):
                 # Let 'requests' decode raw data automatically
                 r.raw.decode_content = True
             try:
-                header, body = self._get_soap_parts(response=r, **parse_opts)
+                header, body = self._get_soap_parts(response=r)
             except Exception:
                 r.close()  # Release memory
                 raise
             # The body may contain error messages from Exchange, but we still want to collect version info
             if header is not None:
-                self._update_api_version(api_version=api_version, header=header, **parse_opts)
+                self._update_api_version(api_version=api_version, header=header)
             try:
-                return self._get_soap_messages(body=body, **parse_opts)
+                return self._get_soap_messages(body=body)
             except (
                 ErrorInvalidServerVersion,
                 ErrorIncorrectSchemaVersion,
@@ -438,7 +439,7 @@ def _handle_backoff(self, e):
         self.protocol.retry_policy.back_off(e.back_off)
         # We'll warn about this later if we actually need to sleep
 
-    def _update_api_version(self, api_version, header, **parse_opts):
+    def _update_api_version(self, api_version, header):
         """Parse the server version contained in SOAP headers and update the version hint stored by the caller, if
         necessary.
         """
@@ -471,7 +472,7 @@ def _response_message_tag(cls):
         return f"{{{MNS}}}{cls.SERVICE_NAME}ResponseMessage"
 
     @classmethod
-    def _get_soap_parts(cls, response, **parse_opts):
+    def _get_soap_parts(cls, response):
         """Split the SOAP response into its headers and body elements."""
         try:
             root = to_xml(response.iter_content())
@@ -486,7 +487,7 @@ def _get_soap_parts(cls, response, **parse_opts):
             raise MalformedResponseError("No Body element in SOAP response")
         return header, body
 
-    def _get_soap_messages(self, body, **parse_opts):
+    def _get_soap_messages(self, body):
         """Return the elements in the response containing the response messages. Raises any SOAP exceptions."""
         response = body.find(self._response_tag())
         if response is None:

exchangelib/services/get_attachment.py

@@ -65,23 +65,20 @@ def get_payload(self, items, include_mime_content, body_type, filter_html_conten
         payload.append(attachment_ids_element(items=items, version=self.account.version))
         return payload
 
-    def _update_api_version(self, api_version, header, **parse_opts):
-        if not parse_opts.get("stream_file_content", False):
-            super()._update_api_version(api_version, header, **parse_opts)
+    def _update_api_version(self, api_version, header):
+        if not self.streaming:
+            super()._update_api_version(api_version, header)
         # TODO: We're skipping this part in streaming mode because StreamingBase64Parser cannot parse the SOAP header
 
-    @classmethod
-    def _get_soap_parts(cls, response, **parse_opts):
-        if not parse_opts.get("stream_file_content", False):
-            return super()._get_soap_parts(response, **parse_opts)
-
+    def _get_soap_parts(self, response):
+        if not self.streaming:
+            return super()._get_soap_parts(response)
         # Pass the response unaltered. We want to use our custom streaming parser
         return None, response
 
-    def _get_soap_messages(self, body, **parse_opts):
-        if not parse_opts.get("stream_file_content", False):
-            return super()._get_soap_messages(body, **parse_opts)
-
+    def _get_soap_messages(self, body):
+        if not self.streaming:
+            return super()._get_soap_messages(body)
         # 'body' is actually the raw response passed on by '_get_soap_parts'
         r = body
         parser = StreamingBase64Parser()
@@ -101,13 +98,14 @@ def stream_file_content(self, attachment_id):
         )
         self.streaming = True
         try:
-            yield from self._get_response_xml(payload=payload, stream_file_content=True)
+            yield from self._get_response_xml(payload=payload)
         except ElementNotFound as enf:
             # When the returned XML does not contain a Content element, ElementNotFound is thrown by parser.parse().
             # Let the non-streaming SOAP parser parse the response and hook into the normal exception handling.
             # Wrap in DummyResponse because _get_soap_parts() expects an iter_content() method.
             response = DummyResponse(content=enf.data)
             _, body = super()._get_soap_parts(response=response)
+            # TODO: We're skipping ._update_api_version() here because we don't have access to the 'api_version' used.
             res = super()._get_soap_messages(body=body)
             for e in self._get_elements_in_response(response=res):
                 if isinstance(e, Exception):

exchangelib/services/get_streaming_events.py

@@ -48,11 +48,11 @@ def _elem_to_obj(self, elem):
         return Notification.from_xml(elem=elem, account=None)
 
     @classmethod
-    def _get_soap_parts(cls, response, **parse_opts):
+    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, **parse_opts):
+    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.
@@ -61,13 +61,13 @@ def _get_soap_messages(self, body, **parse_opts):
             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, **parse_opts)
+                _, 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, **parse_opts)
+            yield from super()._get_soap_messages(body=body)
             if self.connection_status == self.CLOSED:
                 # Don't wait for the TCP connection to timeout
                 break
@@ -97,9 +97,6 @@ def get_payload(self, subscription_ids, connection_timeout):
         subscriptions_elem = create_element("m:SubscriptionIds")
         for subscription_id in subscription_ids:
             add_xml_child(subscriptions_elem, "t:SubscriptionId", subscription_id)
-        if not len(subscriptions_elem):
-            raise ValueError("'subscription_ids' must not be empty")
-
         payload.append(subscriptions_elem)
         add_xml_child(payload, "m:ConnectionTimeout", connection_timeout)
         return payload

exchangelib/services/get_user_settings.py

@@ -53,14 +53,10 @@ def get_payload(self, users, settings):
             mailbox = create_element("a:Mailbox")
             set_xml_value(mailbox, user)
             add_xml_child(users_elem, "a:User", mailbox)
-        if not len(users_elem):
-            raise ValueError("'users' must not be empty")
         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])
-        if not len(requested_settings):
-            raise ValueError("'requested_settings' must not be empty")
         request.append(requested_settings)
         payload.append(request)
         return payload

exchangelib/services/subscribe.py

@@ -51,8 +51,6 @@ def _partial_payload(self, folders, event_types):
         event_types_elem = create_element("t:EventTypes")
         for event_type in event_types:
             add_xml_child(event_types_elem, "t:EventType", event_type)
-        if not len(event_types_elem):
-            raise ValueError("'event_types' must not be empty")
         request_elem.append(event_types_elem)
         return request_elem
 

exchangelib/util.py

@@ -422,10 +422,8 @@ def tell(self):
         return self._tell
 
     def read(self, size=-1):
-        # requests `iter_content()` auto-adjusts the number of bytes based on bandwidth
-        # can't assume how many bytes next returns so stash any extra in `self._next`
-        if self.closed:
-            raise ValueError("read from a closed file")
+        # requests `iter_content()` auto-adjusts the number of bytes based on bandwidth.
+        # We can't assume how many bytes next returns so stash any extra in `self._next`.
         if self._next is None:
             return b""
         if size is None:
@@ -534,10 +532,9 @@ def to_xml(bytes_content):
             offending_line = stream.read().splitlines()[e.lineno - 1]
         except (IndexError, io.UnsupportedOperation):
             raise ParseError(str(e), "<not from file>", e.lineno, e.offset)
-        else:
-            offending_excerpt = offending_line[max(0, e.offset - 20) : e.offset + 20]
-            msg = f'{e}\nOffending text: [...]{offending_excerpt.decode("utf-8", errors="ignore")}[...]'
-            raise ParseError(msg, "<not from file>", e.lineno, e.offset)
+        offending_excerpt = offending_line[max(0, e.offset - 20) : e.offset + 20]
+        msg = f'{e}\nOffending text: [...]{offending_excerpt.decode("utf-8", errors="ignore")}[...]'
+        raise ParseError(msg, "<not from file>", e.lineno, e.offset)
     except TypeError:
         with suppress(IndexError, io.UnsupportedOperation):
             stream.seek(0)
@@ -576,7 +573,8 @@ def is_xml(text):
 class PrettyXmlHandler(logging.StreamHandler):
     """A steaming log handler that prettifies log statements containing XML when output is a terminal."""
 
-    def parse_bytes(self, xml_bytes):
+    @staticmethod
+    def parse_bytes(xml_bytes):
         return to_xml(xml_bytes)
 
     def prettify_xml(self, xml_bytes):
@@ -671,7 +669,7 @@ def iter_content(self):
         return self.content
 
     def close(self):
-        pass
+        """We don't have an actual socket to close"""
 
 
 def get_domain(email):