ominfra 0.0.0.dev78__tar.gz → 0.0.0.dev80__tar.gz

{ominfra-0.0.0.dev78/ominfra.egg-info → ominfra-0.0.0.dev80}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ominfra
-Version: 0.0.0.dev78
+Version: 0.0.0.dev80
 Summary: ominfra
 Author: wrmsr
 License: BSD-3-Clause
@@ -12,8 +12,8 @@ Classifier: Operating System :: OS Independent
 Classifier: Operating System :: POSIX
 Requires-Python: ~=3.12
 License-File: LICENSE
-Requires-Dist: omdev==0.0.0.dev78
-Requires-Dist: omlish==0.0.0.dev78
+Requires-Dist: omdev==0.0.0.dev80
+Requires-Dist: omlish==0.0.0.dev80
 Provides-Extra: all
 Requires-Dist: paramiko~=3.5; extra == "all"
 Requires-Dist: asyncssh~=2.17; python_version < "3.13" and extra == "all"

{ominfra-0.0.0.dev78 → ominfra-0.0.0.dev80}/ominfra/scripts/supervisor.py

@@ -596,81 +596,88 @@ class PollPoller(BasePoller):
         return False
 
 
-class KqueuePoller(BasePoller):
-    max_events = 1000
+if sys.platform == 'darwin' or sys.platform.startswith('freebsd'):
+    class KqueuePoller(BasePoller):
+        max_events = 1000
 
-    def __init__(self) -> None:
-        super().__init__()
+        def __init__(self) -> None:
+            super().__init__()
 
-        self._kqueue: ta.Optional[ta.Any] = select.kqueue()
-        self._readables: set[int] = set()
-        self._writables: set[int] = set()
+            self._kqueue: ta.Optional[ta.Any] = select.kqueue()
+            self._readables: set[int] = set()
+            self._writables: set[int] = set()
 
-    def register_readable(self, fd: int) -> None:
-        self._readables.add(fd)
-        kevent = select.kevent(fd, filter=select.KQ_FILTER_READ, flags=select.KQ_EV_ADD)
-        self._kqueue_control(fd, kevent)
+        def register_readable(self, fd: int) -> None:
+            self._readables.add(fd)
+            kevent = select.kevent(fd, filter=select.KQ_FILTER_READ, flags=select.KQ_EV_ADD)
+            self._kqueue_control(fd, kevent)
 
-    def register_writable(self, fd: int) -> None:
-        self._writables.add(fd)
-        kevent = select.kevent(fd, filter=select.KQ_FILTER_WRITE, flags=select.KQ_EV_ADD)
-        self._kqueue_control(fd, kevent)
+        def register_writable(self, fd: int) -> None:
+            self._writables.add(fd)
+            kevent = select.kevent(fd, filter=select.KQ_FILTER_WRITE, flags=select.KQ_EV_ADD)
+            self._kqueue_control(fd, kevent)
 
-    def unregister_readable(self, fd: int) -> None:
-        kevent = select.kevent(fd, filter=select.KQ_FILTER_READ, flags=select.KQ_EV_DELETE)
-        self._readables.discard(fd)
-        self._kqueue_control(fd, kevent)
+        def unregister_readable(self, fd: int) -> None:
+            kevent = select.kevent(fd, filter=select.KQ_FILTER_READ, flags=select.KQ_EV_DELETE)
+            self._readables.discard(fd)
+            self._kqueue_control(fd, kevent)
 
-    def unregister_writable(self, fd: int) -> None:
-        kevent = select.kevent(fd, filter=select.KQ_FILTER_WRITE, flags=select.KQ_EV_DELETE)
-        self._writables.discard(fd)
-        self._kqueue_control(fd, kevent)
+        def unregister_writable(self, fd: int) -> None:
+            kevent = select.kevent(fd, filter=select.KQ_FILTER_WRITE, flags=select.KQ_EV_DELETE)
+            self._writables.discard(fd)
+            self._kqueue_control(fd, kevent)
 
-    def _kqueue_control(self, fd: int, kevent: 'select.kevent') -> None:
-        try:
-            self._kqueue.control([kevent], 0)  # type: ignore
-        except OSError as error:
-            if error.errno == errno.EBADF:
-                log.debug('EBADF encountered in kqueue. Invalid file descriptor %s', fd)
-            else:
-                raise
+        def _kqueue_control(self, fd: int, kevent: 'select.kevent') -> None:
+            try:
+                self._kqueue.control([kevent], 0)  # type: ignore
+            except OSError as error:
+                if error.errno == errno.EBADF:
+                    log.debug('EBADF encountered in kqueue. Invalid file descriptor %s', fd)
+                else:
+                    raise
 
-    def poll(self, timeout: ta.Optional[float]) -> ta.Tuple[ta.List[int], ta.List[int]]:
-        readables, writables = [], []  # type: ignore
+        def poll(self, timeout: ta.Optional[float]) -> ta.Tuple[ta.List[int], ta.List[int]]:
+            readables, writables = [], []  # type: ignore
 
-        try:
-            kevents = self._kqueue.control(None, self.max_events, timeout)  # type: ignore
-        except OSError as error:
-            if error.errno == errno.EINTR:
-                log.debug('EINTR encountered in poll')
-                return readables, writables
-            raise
+            try:
+                kevents = self._kqueue.control(None, self.max_events, timeout)  # type: ignore
+            except OSError as error:
+                if error.errno == errno.EINTR:
+                    log.debug('EINTR encountered in poll')
+                    return readables, writables
+                raise
 
-        for kevent in kevents:
-            if kevent.filter == select.KQ_FILTER_READ:
-                readables.append(kevent.ident)
-            if kevent.filter == select.KQ_FILTER_WRITE:
-                writables.append(kevent.ident)
+            for kevent in kevents:
+                if kevent.filter == select.KQ_FILTER_READ:
+                    readables.append(kevent.ident)
+                if kevent.filter == select.KQ_FILTER_WRITE:
+                    writables.append(kevent.ident)
 
-        return readables, writables
+            return readables, writables
 
-    def before_daemonize(self) -> None:
-        self.close()
+        def before_daemonize(self) -> None:
+            self.close()
 
-    def after_daemonize(self) -> None:
-        self._kqueue = select.kqueue()
-        for fd in self._readables:
-            self.register_readable(fd)
-        for fd in self._writables:
-            self.register_writable(fd)
+        def after_daemonize(self) -> None:
+            self._kqueue = select.kqueue()
+            for fd in self._readables:
+                self.register_readable(fd)
+            for fd in self._writables:
+                self.register_writable(fd)
 
-    def close(self) -> None:
-        self._kqueue.close()  # type: ignore
-        self._kqueue = None
+        def close(self) -> None:
+            self._kqueue.close()  # type: ignore
+            self._kqueue = None
+
+else:
+    KqueuePoller = None
 
 
 Poller: ta.Type[BasePoller]
-if hasattr(select, 'kqueue'):
+if (
+        sys.platform == 'darwin' or sys.platform.startswith('freebsd') and
+        hasattr(select, 'kqueue') and KqueuePoller is not None
+):
     Poller = KqueuePoller
 elif hasattr(select, 'poll'):
     Poller = PollPoller

{ominfra-0.0.0.dev78 → ominfra-0.0.0.dev80}/ominfra/supervisor/poller.py

@@ -3,6 +3,7 @@ import abc
 import errno
 import logging
 import select
+import sys
 import typing as ta
 
 
@@ -150,81 +151,88 @@ class PollPoller(BasePoller):
         return False
 
 
-class KqueuePoller(BasePoller):
-    max_events = 1000
+if sys.platform == 'darwin' or sys.platform.startswith('freebsd'):
+    class KqueuePoller(BasePoller):
+        max_events = 1000
 
-    def __init__(self) -> None:
-        super().__init__()
-
-        self._kqueue: ta.Optional[ta.Any] = select.kqueue()
-        self._readables: set[int] = set()
-        self._writables: set[int] = set()
+        def __init__(self) -> None:
+            super().__init__()
 
-    def register_readable(self, fd: int) -> None:
-        self._readables.add(fd)
-        kevent = select.kevent(fd, filter=select.KQ_FILTER_READ, flags=select.KQ_EV_ADD)
-        self._kqueue_control(fd, kevent)
+            self._kqueue: ta.Optional[ta.Any] = select.kqueue()
+            self._readables: set[int] = set()
+            self._writables: set[int] = set()
 
-    def register_writable(self, fd: int) -> None:
-        self._writables.add(fd)
-        kevent = select.kevent(fd, filter=select.KQ_FILTER_WRITE, flags=select.KQ_EV_ADD)
-        self._kqueue_control(fd, kevent)
+        def register_readable(self, fd: int) -> None:
+            self._readables.add(fd)
+            kevent = select.kevent(fd, filter=select.KQ_FILTER_READ, flags=select.KQ_EV_ADD)
+            self._kqueue_control(fd, kevent)
 
-    def unregister_readable(self, fd: int) -> None:
-        kevent = select.kevent(fd, filter=select.KQ_FILTER_READ, flags=select.KQ_EV_DELETE)
-        self._readables.discard(fd)
-        self._kqueue_control(fd, kevent)
+        def register_writable(self, fd: int) -> None:
+            self._writables.add(fd)
+            kevent = select.kevent(fd, filter=select.KQ_FILTER_WRITE, flags=select.KQ_EV_ADD)
+            self._kqueue_control(fd, kevent)
 
-    def unregister_writable(self, fd: int) -> None:
-        kevent = select.kevent(fd, filter=select.KQ_FILTER_WRITE, flags=select.KQ_EV_DELETE)
-        self._writables.discard(fd)
-        self._kqueue_control(fd, kevent)
+        def unregister_readable(self, fd: int) -> None:
+            kevent = select.kevent(fd, filter=select.KQ_FILTER_READ, flags=select.KQ_EV_DELETE)
+            self._readables.discard(fd)
+            self._kqueue_control(fd, kevent)
 
-    def _kqueue_control(self, fd: int, kevent: 'select.kevent') -> None:
-        try:
-            self._kqueue.control([kevent], 0)  # type: ignore
-        except OSError as error:
-            if error.errno == errno.EBADF:
-                log.debug('EBADF encountered in kqueue. Invalid file descriptor %s', fd)
-            else:
+        def unregister_writable(self, fd: int) -> None:
+            kevent = select.kevent(fd, filter=select.KQ_FILTER_WRITE, flags=select.KQ_EV_DELETE)
+            self._writables.discard(fd)
+            self._kqueue_control(fd, kevent)
+
+        def _kqueue_control(self, fd: int, kevent: 'select.kevent') -> None:
+            try:
+                self._kqueue.control([kevent], 0)  # type: ignore
+            except OSError as error:
+                if error.errno == errno.EBADF:
+                    log.debug('EBADF encountered in kqueue. Invalid file descriptor %s', fd)
+                else:
+                    raise
+
+        def poll(self, timeout: ta.Optional[float]) -> ta.Tuple[ta.List[int], ta.List[int]]:
+            readables, writables = [], []  # type: ignore
+
+            try:
+                kevents = self._kqueue.control(None, self.max_events, timeout)  # type: ignore
+            except OSError as error:
+                if error.errno == errno.EINTR:
+                    log.debug('EINTR encountered in poll')
+                    return readables, writables
                 raise
 
-    def poll(self, timeout: ta.Optional[float]) -> ta.Tuple[ta.List[int], ta.List[int]]:
-        readables, writables = [], []  # type: ignore
+            for kevent in kevents:
+                if kevent.filter == select.KQ_FILTER_READ:
+                    readables.append(kevent.ident)
+                if kevent.filter == select.KQ_FILTER_WRITE:
+                    writables.append(kevent.ident)
 
-        try:
-            kevents = self._kqueue.control(None, self.max_events, timeout)  # type: ignore
-        except OSError as error:
-            if error.errno == errno.EINTR:
-                log.debug('EINTR encountered in poll')
-                return readables, writables
-            raise
+            return readables, writables
 
-        for kevent in kevents:
-            if kevent.filter == select.KQ_FILTER_READ:
-                readables.append(kevent.ident)
-            if kevent.filter == select.KQ_FILTER_WRITE:
-                writables.append(kevent.ident)
+        def before_daemonize(self) -> None:
+            self.close()
 
-        return readables, writables
+        def after_daemonize(self) -> None:
+            self._kqueue = select.kqueue()
+            for fd in self._readables:
+                self.register_readable(fd)
+            for fd in self._writables:
+                self.register_writable(fd)
 
-    def before_daemonize(self) -> None:
-        self.close()
+        def close(self) -> None:
+            self._kqueue.close()  # type: ignore
+            self._kqueue = None
 
-    def after_daemonize(self) -> None:
-        self._kqueue = select.kqueue()
-        for fd in self._readables:
-            self.register_readable(fd)
-        for fd in self._writables:
-            self.register_writable(fd)
-
-    def close(self) -> None:
-        self._kqueue.close()  # type: ignore
-        self._kqueue = None
+else:
+    KqueuePoller = None
 
 
 Poller: ta.Type[BasePoller]
-if hasattr(select, 'kqueue'):
+if (
+        sys.platform == 'darwin' or sys.platform.startswith('freebsd') and
+        hasattr(select, 'kqueue') and KqueuePoller is not None
+):
     Poller = KqueuePoller
 elif hasattr(select, 'poll'):
     Poller = PollPoller

{ominfra-0.0.0.dev78 → ominfra-0.0.0.dev80/ominfra.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ominfra
-Version: 0.0.0.dev78
+Version: 0.0.0.dev80
 Summary: ominfra
 Author: wrmsr
 License: BSD-3-Clause
@@ -12,8 +12,8 @@ Classifier: Operating System :: OS Independent
 Classifier: Operating System :: POSIX
 Requires-Python: ~=3.12
 License-File: LICENSE
-Requires-Dist: omdev==0.0.0.dev78
-Requires-Dist: omlish==0.0.0.dev78
+Requires-Dist: omdev==0.0.0.dev80
+Requires-Dist: omlish==0.0.0.dev80
 Provides-Extra: all
 Requires-Dist: paramiko~=3.5; extra == "all"
 Requires-Dist: asyncssh~=2.17; python_version < "3.13" and extra == "all"

{ominfra-0.0.0.dev78 → ominfra-0.0.0.dev80}/ominfra.egg-info/requires.txt

@@ -1,5 +1,5 @@
-omdev==0.0.0.dev78
-omlish==0.0.0.dev78
+omdev==0.0.0.dev80
+omlish==0.0.0.dev80
 
 [all]
 paramiko~=3.5

{ominfra-0.0.0.dev78 → ominfra-0.0.0.dev80}/pyproject.toml

@@ -12,7 +12,7 @@ authors = [
 urls = {source = 'https://github.com/wrmsr/omlish'}
 license = {text = 'BSD-3-Clause'}
 requires-python = '~=3.12'
-version = '0.0.0.dev78'
+version = '0.0.0.dev80'
 classifiers = [
     'License :: OSI Approved :: BSD License',
     'Development Status :: 2 - Pre-Alpha',
@@ -22,8 +22,8 @@ classifiers = [
 ]
 description = 'ominfra'
 dependencies = [
-    'omdev == 0.0.0.dev78',
-    'omlish == 0.0.0.dev78',
+    'omdev == 0.0.0.dev80',
+    'omlish == 0.0.0.dev80',
 ]
 
 [project.optional-dependencies]