Patched code sample

import pycares
import asyncio
import gc

class SafeChannel:
    def __init__(self):
        self._channel = pycares.Channel()
        self._pending_queries = set()
        self._loop = asyncio.get_event_loop()

    def query(self, host, query_type, callback):
        """Submits a DNS query and tracks it."""
        try:
            query_id = self._channel.query(host, query_type, callback)
            self._pending_queries.add(query_id) # Assuming query() returns a unique ID
        except pycares.error.AresError as e:
            print(f"Query failed: {e}")
        
        return query_id


    def _query_done_callback(self, query_id):
        """Removes a query from the pending set when it's done."""
        if query_id in self._pending_queries:
            self._pending_queries.remove(query_id)

    async def close(self):
        """Safely closes the channel, cancelling pending queries."""
        # Cancel any pending queries before closing the channel.
        # Cancellation might not be possible with all DNS queries.  Handle errors gracefully.

        while self._pending_queries:
            try:
                 query_id = self._pending_queries.pop()
            except KeyError:
                 break  # The set could be empty because of concurent task completion.

            # Attempt to cancel or ignore if cancellation fails
            try:
                #cancellation not directly supported by pycares, simulating
                #the effect by simply waiting
                await asyncio.sleep(0.001)
            except Exception as e:
                print(f"Error cancelling query {query_id}: {e}")

        self._channel.cancel()
        self._channel = None # prevent access after closing
        self._pending_queries = None  #Prevent access after closing
        self._loop = None


    def __del__(self):
        """Destructor to ensure channel is closed when garbage collected."""
        if hasattr(self, '_channel') and self._channel is not None:
            print("WARNING: Channel was not explicitly closed.  Closing now...")
            #try to clean up.  This *may* still cause issues if there are callbacks actively using the object.
            if hasattr(self, '_loop') and self._loop is not None and self._loop.is_running():
                asyncio.run(self.close())
            else:
                self._channel.cancel()  # Try cancelling even without an event loop.
                self._channel = None

async def main():
    safe_channel = SafeChannel()

    def my_callback(result, error):
        print(f"Result: {result}, Error: {error}")
        safe_channel._query_done_callback(query_id)

    query_id = safe_channel.query("example.com", pycares.QUERY_TYPE_A, my_callback)


    await asyncio.sleep(0.1) #Simulate waiting for some time for the request to complete.
    await safe_channel.close()  # Explicitly close the channel


if __name__ == "__main__":
    asyncio.run(main())