============================= test session starts ==============================
platform linux -- Python 3.12.3, pytest-8.1.1, pluggy-1.4.0
rootdir: /build/source
configfile: setup.cfg
testpaths: tests
collected 1 item                                                               

tests/test_observer.py F                                                 [100%]

=================================== FAILURES ===================================
____________________ test_can_watch_for_changes_with_gevent ____________________

    def test_can_watch_for_changes_with_gevent():
        # Given a gevent-based thread that counts stuff and sleeps every second
        count = 0
    
        def counter():
            nonlocal count
            while True:
                count += 1
                time.sleep(1)
    
        counter_thread = Thread(target=counter, daemon=True)
        counter_thread.start()
    
        # And an event handler that gets notified when this file changes
        events = []
    
        class Handler(FileSystemEventHandler):
            def on_any_event(self, event):
                events.append(event)
    
        # And an observer that dispatches to that handler
        try:
            observer = Observer()
>           observer.schedule(Handler(), rel(".."), recursive=True)

tests/test_observer.py:40: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <GeventObserver(Thread-2, initial daemon)>
event_handler = <tests.test_observer.test_can_watch_for_changes_with_gevent.<locals>.Handler object at 0x7ffff60cf6e0>
path = '/build/source', recursive = True, event_filter = None

    def schedule(self, event_handler, path, recursive=False, event_filter=None):
        """
        Schedules watching a path and calls appropriate methods specified
        in the given event handler in response to file system events.
    
        :param event_handler:
            An event handler instance that has appropriate event handling
            methods which will be called by the observer in response to
            file system events.
        :type event_handler:
            :class:`watchdog.events.FileSystemEventHandler` or a subclass
        :param path:
            Directory path that will be monitored.
        :type path:
            ``str``
        :param recursive:
            ``True`` if events will be emitted for sub-directories
            traversed recursively; ``False`` otherwise.
        :type recursive:
            ``bool``
        :param event_filter:
            Collection of event types to emit, or None for no filtering (default).
        :type event_filter:
            Optional[Iterable[:class:`watchdog.events.FileSystemEvent`]]
        :return:
            An :class:`ObservedWatch` object instance representing
            a watch.
        """
        with self._lock:
            watch = ObservedWatch(path, recursive, event_filter)
            self._add_handler_for_watch(event_handler, watch)
    
            # If we don't have an emitter for this watch already, create it.
            if self._emitter_for_watch.get(watch) is None:
>               emitter = self._emitter_class(event_queue=self.event_queue, watch=watch, timeout=self.timeout,
                                              event_filter=event_filter)
E               TypeError: GeventEmitter.__init__() got an unexpected keyword argument 'event_filter'

/nix/store/wgnc664dbcaykwhkaf3k9bvvy8skzcv3-python3.12-watchdog-4.0.0/lib/python3.12/site-packages/watchdog/observers/api.py:320: TypeError

During handling of the above exception, another exception occurred:

    def test_can_watch_for_changes_with_gevent():
        # Given a gevent-based thread that counts stuff and sleeps every second
        count = 0
    
        def counter():
            nonlocal count
            while True:
                count += 1
                time.sleep(1)
    
        counter_thread = Thread(target=counter, daemon=True)
        counter_thread.start()
    
        # And an event handler that gets notified when this file changes
        events = []
    
        class Handler(FileSystemEventHandler):
            def on_any_event(self, event):
                events.append(event)
    
        # And an observer that dispatches to that handler
        try:
            observer = Observer()
            observer.schedule(Handler(), rel(".."), recursive=True)
            observer.start()
    
            # When I touch this file
            subprocess.run(["touch", __file__])
    
            # And wait a second
            time.sleep(1)
    
            # Then the counter should have incremented
            assert count >= 2
    
            # And the event should have been observed
            assert events == [
                FileModifiedEvent(__file__)
            ]
        finally:
            observer.stop()
>           observer.join()

tests/test_observer.py:58: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <GeventObserver(Thread-2, initial daemon)>, timeout = None

    def join(self, timeout=None):
        """Wait until the thread terminates.
    
        This blocks the calling thread until the thread whose join() method is
        called terminates -- either normally or through an unhandled exception
        or until the optional timeout occurs.
    
        When the timeout argument is present and not None, it should be a
        floating point number specifying a timeout for the operation in seconds
        (or fractions thereof). As join() always returns None, you must call
        is_alive() after join() to decide whether a timeout happened -- if the
        thread is still alive, the join() call timed out.
    
        When the timeout argument is not present or None, the operation will
        block until the thread terminates.
    
        A thread can be join()ed many times.
    
        join() raises a RuntimeError if an attempt is made to join the current
        thread as that would cause a deadlock. It is also an error to join() a
        thread before it has been started and attempts to do so raises the same
        exception.
    
        """
        if not self._initialized:
            raise RuntimeError("Thread.__init__() not called")
        if not self._started.is_set():
>           raise RuntimeError("cannot join thread before it is started")
E           RuntimeError: cannot join thread before it is started

/nix/store/m51f0kclg01xdc0mjxqs5cpyaxqbqhg5-python3-3.12.3/lib/python3.12/threading.py:1142: RuntimeError
=========================== short test summary info ============================
FAILED tests/test_observer.py::test_can_watch_for_changes_with_gevent - RuntimeError: cannot join thread before it is started
============================== 1 failed in 0.04s ===============================
``