Improve search and operations layer; add is-not-defined filter workarounds

search.py:
- Add search.is-not-defined.category and search.is-not-defined.dtend
  sub-features with client-side workarounds for servers that do not
  support the CALDAV:is-not-defined filter natively
- Fix get_object_by_uid() to route through search() so that server-specific
  delays and retry logic are honoured

operations/search_ops.py:
- Gracefully handle invalid recurrence data that some servers return

operations/calendarset_ops.py:
- Minor fixes discovered during multi-server testing

Co-Authored-By: Claude <noreply@anthropic.com>

Author: tobixen

caldav/operations/calendarset_ops.py

@@ -11,7 +11,7 @@
 import logging
 from dataclasses import dataclass
 from typing import Any
-from urllib.parse import quote
+from urllib.parse import quote, unquote, urlparse, urlunparse
 
 log = logging.getLogger("caldav")
 
@@ -183,6 +183,25 @@ def _find_calendar_by_id(
     return None
 
 
+def _quote_url_path(url: str) -> str:
+    """
+    Quote the path component of a URL to handle spaces and special characters.
+
+    Some servers (e.g., Zimbra) return URLs with unencoded spaces in the path.
+    This function ensures the path is properly percent-encoded.
+
+    Args:
+        url: URL string that may contain unencoded characters in path
+
+    Returns:
+        URL with properly encoded path
+    """
+    parsed = urlparse(url)
+    # quote the path, but unquote first to avoid double-encoding
+    quoted_path = quote(unquote(parsed.path), safe="/@")
+    return urlunparse(parsed._replace(path=quoted_path))
+
+
 def _extract_calendars_from_propfind_results(
     results: list[Any] | None,
 ) -> list[CalendarInfo]:
@@ -206,8 +225,8 @@ def _extract_calendars_from_propfind_results(
         if not is_calendar_resource(result.properties):
             continue
 
-        # Extract calendar info
-        url = result.href
+        # Extract calendar info - quote URL path to handle spaces
+        url = _quote_url_path(result.href)
         name = result.properties.get("{DAV:}displayname")
         cal_id = _extract_calendar_id_from_url(url)
 

caldav/operations/search_ops.py

@@ -240,7 +240,15 @@ def _filter_search_results(
     result = []
     for o in objects:
         if searcher.expand or post_filter:
-            filtered = searcher.check_component(o, expand_only=not post_filter)
+            try:
+                filtered = searcher.check_component(o, expand_only=not post_filter)
+            except ValueError:
+                ## Server returned data with invalid recurrence structure
+                ## (e.g. after compatibility hacks stripped DURATION).
+                ## Include the object unfiltered rather than crashing.
+                filtered = [
+                    x for x in o.icalendar_instance.subcomponents if not isinstance(x, Timezone)
+                ]
             if not filtered:
                 continue
         else:
@@ -392,9 +400,10 @@ def _build_search_xml_query(
         raise error.ConsistencyError(f"unsupported comp class {comp_class} for search")
 
     # Special hack for bedework - no comp_filter, do client-side filtering
+    # Keep comp_class so the caller knows what type to filter for client-side
+    # and to prevent _search_with_comptypes from being triggered again
     if _hacks == "no_comp_filter":
         comp_filter = None
-        comp_class = None
 
     # Add property filters
     for property in searcher._property_operator:

caldav/search.py

@@ -29,6 +29,25 @@
 _collation_to_caldav = collation_to_caldav
 
 
+def _is_not_defined_supported(features: Any, prop: str) -> bool:
+    """Check if is-not-defined search is supported for a specific property.
+
+    Checks the property-specific sub-feature (e.g. search.is-not-defined.category
+    or search.is-not-defined.dtend) if one is defined, otherwise falls back to
+    the parent search.is-not-defined feature.
+
+    The ``categories`` → ``category`` mapping exists because the feature is named
+    after the singular form while the iCalendar property is plural.
+    """
+    from .compatibility_hints import FeatureSet
+
+    feature_prop = "category" if prop == "categories" else prop
+    sub_feature = f"search.is-not-defined.{feature_prop}"
+    if sub_feature in FeatureSet.FEATURES:
+        return features.is_supported(sub_feature)
+    return features.is_supported("search.is-not-defined")
+
+
 # Property filter attribute names used for cloning searchers with modified filters
 _PROPERTY_FILTER_ATTRS = (
     "_property_filters",
@@ -229,13 +248,14 @@ def _search_impl(
 
         ## Handle servers with broken component-type filtering (e.g., Bedework)
         comp_type_support = calendar.client.features.is_supported("search.comp-type", str)
-        if (
+        no_comp_filter = (
             (self.comp_class or self.todo or self.event or self.journal)
             and comp_type_support == "broken"
-            and not _hacks
             and post_filter is not False
-        ):
-            _hacks = "no_comp_filter"
+        )
+        if no_comp_filter:
+            if not _hacks:
+                _hacks = "no_comp_filter"
             post_filter = True
 
         ## Setting default value for post_filter
@@ -257,6 +277,29 @@ def _search_impl(
             if not self.start or not self.end:
                 raise error.ReportError("can't expand without a date range")
 
+        ## special compatibility-case for servers that do not support text search at all
+        ## (e.g. purelymail where both i;octet and i;ascii-casemap collations are unsupported).
+        ## Remove all text-value filters and rely on client-side post_filter instead.
+        if (
+            not calendar.client.features.is_supported("search.text")
+            and self._property_filters
+            and post_filter is not False
+        ):
+            text_filter_props = [
+                prop for prop, op in self._property_operator.items() if op != "undef"
+            ]
+            if text_filter_props:
+                clone = self._clone_without_filters(text_filter_props)
+                objects = yield (
+                    SearchAction.RECURSIVE_SEARCH,
+                    (clone, calendar, server_expand, split_expanded, props, xml, None, None),
+                )
+                yield (
+                    SearchAction.RETURN,
+                    self.filter(objects, post_filter, split_expanded, server_expand),
+                )
+                return
+
         ## special compatbility-case for servers that does not
         ## support category search properly
         if (
@@ -275,6 +318,31 @@ def _search_impl(
             )
             return
 
+        ## special compatibility-case for servers that do not support is-not-defined
+        ## for specific properties (e.g. search.is-not-defined.category or .dtend)
+        if post_filter is not False:
+            undef_props_without_support = [
+                prop
+                for prop, op in self._property_operator.items()
+                if op == "undef" and not _is_not_defined_supported(calendar.client.features, prop)
+            ]
+            if undef_props_without_support:
+                clone = self._clone_without_filters(undef_props_without_support)
+                objects = yield (
+                    SearchAction.RECURSIVE_SEARCH,
+                    (clone, calendar, server_expand, split_expanded, props, xml, None, None),
+                )
+                yield (
+                    SearchAction.RETURN,
+                    self.filter(
+                        objects,
+                        post_filter=True,
+                        split_expanded=split_expanded,
+                        server_expand=server_expand,
+                    ),
+                )
+                return
+
         ## special compatibility-case for servers that do not support substring search
         if (
             not calendar.client.features.is_supported("search.text.substring")
@@ -353,7 +421,8 @@ def _search_impl(
             clone.expand = False
 
             if (
-                calendar.client.features.is_supported("search.text")
+                not no_comp_filter
+                and calendar.client.features.is_supported("search.text")
                 and calendar.client.features.is_supported("search.combined-is-logical-and")
                 and (
                     not calendar.client.features.is_supported(
@@ -440,6 +509,35 @@ def _search_impl(
                 yield (SearchAction.RETURN, result)
                 return
 
+            ## If _hacks=="insist" and still no results despite having text property
+            ## filters, the server may not support text search (e.g. purelymail,
+            ## CCS with i;octet collation).  Retry without the text filters and rely
+            ## on client-side post_filter (which is guaranteed True in get_object_by_uid).
+            if not objects and _hacks == "insist" and self._property_filters:
+                non_undef_filters = [
+                    prop for prop, op in self._property_operator.items() if op != "undef"
+                ]
+                if non_undef_filters:
+                    clone = self._clone_without_filters(non_undef_filters)
+                    result = yield (
+                        SearchAction.RECURSIVE_SEARCH,
+                        (
+                            clone,
+                            calendar,
+                            server_expand,
+                            split_expanded,
+                            props,
+                            orig_xml,
+                            None,
+                            None,
+                        ),
+                    )
+                    yield (
+                        SearchAction.RETURN,
+                        self.filter(result, post_filter, split_expanded, server_expand),
+                    )
+                    return
+
         # Post-process: load objects
         obj2 = []
         for o in objects: