fix: Wire up async-first implementation to public API

Key changes:
- Update caldav/__init__.py to import DAVClient from _sync.davclient
  (the new async-first sync wrapper)
- Fix httpx connection pool issues by creating a fresh client per request
  with connection pooling disabled (max_keepalive_connections=0)
- Use async context manager for httpx client to ensure proper cleanup
- Update search.py to recognize both sync and async component classes
  (Event/AsyncEvent, Todo/AsyncTodo, Journal/AsyncJournal)

This enables the library to use the new async-first httpx implementation
while maintaining full backward compatibility with existing sync code.

Tested against live CalDAV server (Nextcloud):
- Sync client: principal(), calendars(), events() all work
- Async client: same operations work with async/await

🤖 Generated with [Claude Code](https://claude.com/claude-code)

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

Author: cbcoutinho

caldav/__init__.py

@@ -10,7 +10,9 @@
     warnings.warn(
         "You need to install the `build` package and do a `python -m build` to get caldav.__version__ set correctly"
     )
-from .davclient import DAVClient
+
+# Import from the new async-first implementation with sync wrappers
+from ._sync.davclient import DAVClient
 from .search import CalDAVSearcher
 
 ## TODO: this should go away in some future version of the library.

caldav/_async/davclient.py

@@ -445,20 +445,31 @@ def _auto_url(self, url, features):
         return url
 
     async def _get_client(self) -> httpx.AsyncClient:
-        """Get or create the httpx AsyncClient."""
-        if self._client is None:
-            transport = None
-            if self._proxy:
-                transport = httpx.AsyncHTTPTransport(proxy=self._proxy)
-
-            self._client = httpx.AsyncClient(
-                auth=self.auth,
-                timeout=self.timeout,
-                verify=self.ssl_verify_cert,
-                cert=self.ssl_cert,
-                transport=transport,
-            )
-        return self._client
+        """Get or create the httpx AsyncClient.
+
+        When used from sync wrappers (via anyio.run()), we need to create
+        a fresh client each time because the connection pool gets invalidated
+        when the event loop closes.
+        """
+        # Always create a fresh client to avoid event loop issues
+        # The overhead is minimal compared to connection establishment
+        transport = None
+        if self._proxy:
+            transport = httpx.AsyncHTTPTransport(proxy=self._proxy)
+
+        # Disable connection pooling to avoid stale connections
+        # when used from sync context with multiple anyio.run() calls
+        limits = httpx.Limits(max_keepalive_connections=0)
+
+        client = httpx.AsyncClient(
+            auth=self.auth,
+            timeout=self.timeout,
+            verify=self.ssl_verify_cert,
+            cert=self.ssl_cert,
+            transport=transport,
+            limits=limits,
+        )
+        return client
 
     async def __aenter__(self) -> Self:
         await self._get_client()
@@ -518,7 +529,6 @@ async def request(
         This is the core method that all other HTTP methods use.
         """
         headers = headers or {}
-        client = await self._get_client()
 
         combined_headers = dict(self.headers)
         combined_headers.update(headers or {})
@@ -533,49 +543,57 @@ async def request(
             )
         )
 
-        try:
-            r = await client.request(
-                method,
-                str(url_obj),
-                content=to_wire(body) if body else None,
-                headers=combined_headers,
-            )
-            log.debug("server responded with %i %s" % (r.status_code, r.reason_phrase))
-
-            if (
-                r.status_code == 401
-                and "text/html" in self.headers.get("Content-Type", "")
-                and not self.auth
-            ):
-                msg = (
-                    "No authentication object was provided. "
-                    "HTML was returned when probing the server for supported authentication types."
+        # Create a fresh client for each request to avoid event loop issues
+        # when used from sync context with multiple anyio.run() calls
+        async with await self._get_client() as client:
+            try:
+                r = await client.request(
+                    method,
+                    str(url_obj),
+                    content=to_wire(body) if body else None,
+                    headers=combined_headers,
                 )
-                if r.headers.get("WWW-Authenticate"):
-                    auth_types = [
-                        t
-                        for t in self.extract_auth_types(r.headers["WWW-Authenticate"])
-                        if t in ["basic", "digest", "bearer"]
-                    ]
-                    if auth_types:
-                        msg += "\nSupported authentication types: %s" % (
-                            ", ".join(auth_types)
-                        )
-                log.warning(msg)
-            response = DAVResponse(r, self)
-        except httpx.RequestError:
-            if self.auth or not self.password:
-                raise
-            # Workaround for servers that abort connection instead of 401
-            r = await client.request(
-                method="GET",
-                url=str(url_obj),
-                headers=combined_headers,
-            )
-            if r.status_code != 401:
-                raise
+                log.debug(
+                    "server responded with %i %s" % (r.status_code, r.reason_phrase)
+                )
+
+                if (
+                    r.status_code == 401
+                    and "text/html" in self.headers.get("Content-Type", "")
+                    and not self.auth
+                ):
+                    msg = (
+                        "No authentication object was provided. "
+                        "HTML was returned when probing the server for supported authentication types."
+                    )
+                    if r.headers.get("WWW-Authenticate"):
+                        auth_types = [
+                            t
+                            for t in self.extract_auth_types(
+                                r.headers["WWW-Authenticate"]
+                            )
+                            if t in ["basic", "digest", "bearer"]
+                        ]
+                        if auth_types:
+                            msg += "\nSupported authentication types: %s" % (
+                                ", ".join(auth_types)
+                            )
+                    log.warning(msg)
+                response = DAVResponse(r, self)
+            except httpx.RequestError:
+                if self.auth or not self.password:
+                    raise
+                # Workaround for servers that abort connection instead of 401
+                r = await client.request(
+                    method="GET",
+                    url=str(url_obj),
+                    headers=combined_headers,
+                )
+                if r.status_code != 401:
+                    raise
+                response = DAVResponse(r, self)
 
-        # Handle authentication
+        # Handle authentication (outside the client context - will create new client if needed)
         if (
             r.status_code == 401
             and "WWW-Authenticate" in r.headers
@@ -591,11 +609,6 @@ async def request(
                     "supported authentication methods: basic, digest, bearer"
                 )
 
-            # Recreate client with new auth
-            if self._client:
-                await self._client.aclose()
-                self._client = None
-
             return await self.request(url, method, body, headers)
 
         elif (
@@ -613,11 +626,6 @@ async def request(
             self.username = None
             self.password = None
 
-            # Recreate client with new auth
-            if self._client:
-                await self._client.aclose()
-                self._client = None
-
             return await self.request(str(url_obj), method, body, headers)
 
         # Handle authorization errors

caldav/objects.py

@@ -10,8 +10,12 @@
 * CalendarObjectResource base class -> calendarobjectresource.py
 * Event/Todo/Journal/FreeBusy -> calendarobjectresource.py
 * Everything else (mostly collection objects) -> collection.py
+
+The async-first implementation lives in _async/ and _sync/ subdirectories.
+This module exports the sync (backward-compatible) versions.
 """
-## For backward compatibility
+## For backward compatibility - import from original modules
+## These will be gradually migrated to use the _sync wrappers
 from .calendarobjectresource import *
 from .collection import *
 from .davobject import *

caldav/search.py

@@ -444,27 +444,36 @@ def build_search_xml_query(
         ## The only thing I don't support is the component name ('VEVENT').
         ## Anyway, this code section ensures both comp_filter and comp_class
         ## is given.  Or at least, it tries to ensure it.
-        for flag, comp_name, comp_class_ in (
-            ("event", "VEVENT", Event),
-            ("todo", "VTODO", Todo),
-            ("journal", "VJOURNAL", Journal),
+        ## Import async classes for comparison
+        from caldav._async.calendarobjectresource import (
+            AsyncEvent,
+            AsyncJournal,
+            AsyncTodo,
+        )
+
+        for flag, comp_name, comp_classes in (
+            ("event", "VEVENT", (Event, AsyncEvent)),
+            ("todo", "VTODO", (Todo, AsyncTodo)),
+            ("journal", "VJOURNAL", (Journal, AsyncJournal)),
         ):
             flagged = getattr(self, flag)
             if flagged:
                 ## event/journal/todo is set, we adjust comp_class accordingly
-                if self.comp_class is not None and self.comp_class is not comp_class_:
+                if self.comp_class is not None and self.comp_class not in comp_classes:
                     raise error.ConsistencyError(
-                        f"inconsistent search parameters - comp_class = {self.comp_class}, want {comp_class_}"
+                        f"inconsistent search parameters - comp_class = {self.comp_class}, want one of {comp_classes}"
                     )
-                self.comp_class = comp_class_
+                if self.comp_class is None:
+                    self.comp_class = comp_classes[0]
 
             if comp_filter and comp_filter.attributes["name"] == comp_name:
-                self.comp_class = comp_class_
+                if self.comp_class is None:
+                    self.comp_class = comp_classes[0]
                 if flag == "todo" and not self.todo and self.include_completed is None:
                     self.include_completed = True
                 setattr(self, flag, True)
 
-            if self.comp_class == comp_class_:
+            if self.comp_class in comp_classes:
                 if comp_filter:
                     assert comp_filter.attributes["name"] == comp_name
                 else: