omserv 0.0.0.dev7__py3-none-any.whl

omserv/server/tcpserver.py

@@ -0,0 +1,173 @@
+import errno
+import logging
+import math
+import typing as ta
+
+import anyio.abc
+
+from omlish import check
+
+from .config import Config
+from .events import Closed
+from .events import RawData
+from .events import ServerEvent
+from .events import Updated
+from .protocols import ProtocolWrapper
+from .sockets import parse_socket_addr
+from .taskspawner import TaskSpawner
+from .types import AppWrapper
+from .workercontext import WorkerContext
+
+
+log = logging.getLogger(__name__)
+
+
+MAX_RECV = 2 ** 16
+
+
+class TcpServer:
+    def __init__(
+            self,
+            app: AppWrapper,
+            config: Config,
+            context: WorkerContext,
+            stream: anyio.abc.SocketStream,
+    ) -> None:
+        super().__init__()
+
+        self.app = app
+        self.config = config
+        self.context = context
+        self.protocol: ProtocolWrapper
+        self.send_lock = anyio.Lock()
+        self.idle_lock = anyio.Lock()
+        self.stream = stream
+
+        self._idle_handle: anyio.abc.CancelScope | None = None
+        self._task_spawner: TaskSpawner | None = None
+
+    def __await__(self) -> ta.Generator[ta.Any, None, None]:
+        return self.run().__await__()
+
+    async def run(self) -> None:
+        socket = self.stream._raw_socket  # noqa
+
+        try:
+            client = parse_socket_addr(socket.family, socket.getpeername())
+            server = parse_socket_addr(socket.family, socket.getsockname())
+
+            async with TaskSpawner() as task_spawner:
+                self._task_spawner = task_spawner
+
+                self.protocol = ProtocolWrapper(
+                    self.app,
+                    self.config,
+                    self.context,
+                    task_spawner,
+                    client,
+                    server,
+                    self.protocol_send,
+                )
+
+                await self.protocol.initiate()
+                await self._start_idle()
+                await self._read_data()
+
+        except* OSError:
+            pass
+
+        except* Exception as eg:
+            for e in eg.exceptions:
+                log.exception('Internal omlicorn error', exc_info=e)
+
+        finally:
+            await self._close()
+
+    async def protocol_send(self, event: ServerEvent) -> None:
+        if isinstance(event, RawData):
+            async with self.send_lock:
+                try:
+                    with anyio.CancelScope() as cancel_scope:
+                        cancel_scope.shield = True
+                        await self.stream.send(event.data)
+
+                except (anyio.BrokenResourceError, anyio.ClosedResourceError):
+                    await self.protocol.handle(Closed())
+
+        elif isinstance(event, Closed):
+            await self._close()
+            await self.protocol.handle(Closed())
+
+        elif isinstance(event, Updated):
+            if event.idle:
+                await self._start_idle()
+            else:
+                await self._stop_idle()
+
+    async def _read_data(self) -> None:
+        while True:
+            try:
+                with anyio.fail_after(self.config.read_timeout or math.inf):
+                    data = await self.stream.receive(MAX_RECV)
+
+            except (
+                    anyio.EndOfStream,
+                    anyio.ClosedResourceError,
+                    anyio.BrokenResourceError,
+                    TimeoutError,
+            ):
+                break
+
+            else:
+                await self.protocol.handle(RawData(data))
+                if data == b'':
+                    break
+
+        await self.protocol.handle(Closed())
+
+    async def _close(self) -> None:
+        try:
+            await self.stream.send_eof()
+
+        except OSError as e:
+            if e.errno != errno.EBADF:
+                raise
+
+        except (
+                anyio.BrokenResourceError,
+                AttributeError,
+                anyio.BusyResourceError,
+                anyio.ClosedResourceError,
+        ):
+            # They're already gone, nothing to do - or it is a SSL stream
+            pass
+
+        await self.stream.aclose()
+
+    async def _initiate_server_close(self) -> None:
+        await self.protocol.handle(Closed())
+        await self.stream.aclose()
+
+    async def _start_idle(self) -> None:
+        async with self.idle_lock:
+            if self._idle_handle is None:
+                self._idle_handle = await check.not_none(self._task_spawner).start(self._run_idle)
+
+    async def _stop_idle(self) -> None:
+        async with self.idle_lock:
+            if self._idle_handle is not None:
+                self._idle_handle.cancel()
+            self._idle_handle = None
+
+    async def _run_idle(
+            self,
+            task_status: anyio.abc.TaskStatus[ta.Any] = anyio.TASK_STATUS_IGNORED,
+    ) -> None:
+        cancel_scope = anyio.CancelScope()
+        task_status.started(cancel_scope)
+        with cancel_scope:
+            with anyio.move_on_after(self.config.keep_alive_timeout):
+                await self.context.terminated.wait()
+
+            cancel_scope.shield = True
+            await self._initiate_server_close()

omserv/server/types.py

@@ -0,0 +1,94 @@
+import typing as ta
+
+
+##
+
+
+AsgiReceiveEvent: ta.TypeAlias = dict[str, ta.Any]
+AsgiSendEvent: ta.TypeAlias = dict[str, ta.Any]
+
+AsgiReceiveCallable: ta.TypeAlias = ta.Callable[[], ta.Awaitable[AsgiReceiveEvent]]
+AsgiSendCallable: ta.TypeAlias = ta.Callable[[AsgiSendEvent], ta.Awaitable[None]]
+
+Scope: ta.TypeAlias = dict[str, ta.Any]
+AsgiFramework: ta.TypeAlias = ta.Callable[
+    [
+        Scope,
+        AsgiReceiveCallable,
+        AsgiSendCallable,
+    ],
+    ta.Awaitable[None],
+]
+
+LifespanScope: ta.TypeAlias = Scope
+
+HttpResponseStartEvent: ta.TypeAlias = dict[str, ta.Any]
+HttpScope: ta.TypeAlias = Scope
+WebsocketScope: ta.TypeAlias = Scope
+
+WebsocketAcceptEvent: ta.TypeAlias = dict[str, ta.Any]
+WebsocketResponseBodyEvent: ta.TypeAlias = dict[str, ta.Any]
+WebsocketResponseStartEvent: ta.TypeAlias = dict[str, ta.Any]
+
+
+##
+
+
+class UnexpectedMessageError(Exception):
+    pass
+
+
+class AsgiWrapper:
+    def __init__(self, app: AsgiFramework) -> None:
+        super().__init__()
+        self.app = app
+
+    async def __call__(
+            self,
+            scope: Scope,
+            receive: AsgiReceiveCallable,
+            send: AsgiSendCallable,
+            sync_spawn: ta.Callable,
+            call_soon: ta.Callable,
+    ) -> None:
+        await self.app(scope, receive, send)
+
+
+class AppWrapper(ta.Protocol):
+    async def __call__(
+            self,
+            scope: Scope,
+            receive: AsgiReceiveCallable,
+            send: AsgiSendCallable,
+            sync_spawn: ta.Callable,
+            call_soon: ta.Callable,
+    ) -> None:
+        pass
+
+
+def wrap_app(
+        app: AsgiFramework | AppWrapper,
+) -> AppWrapper:
+    if isinstance(app, AsgiWrapper):
+        return app
+    return AsgiWrapper(app)  # type: ignore
+
+
+##
+
+
+class WaitableEvent(ta.Protocol):
+    def __init__(self) -> None:
+        pass
+
+    async def clear(self) -> None:
+        pass
+
+    async def set(self) -> None:
+        pass
+
+    async def wait(self) -> None:
+        pass
+
+    def is_set(self) -> bool:
+        pass

omserv/server/workercontext.py

@@ -0,0 +1,52 @@
+import anyio
+
+from .types import WaitableEvent
+
+
+class WaitableEventWrapper:
+    def __init__(self) -> None:
+        super().__init__()
+        self._event = anyio.Event()
+
+    async def clear(self) -> None:
+        self._event = anyio.Event()
+
+    async def wait(self) -> None:
+        await self._event.wait()
+
+    async def set(self) -> None:
+        self._event.set()
+
+    def is_set(self) -> bool:
+        return self._event.is_set()
+
+
+class WorkerContext:
+    event_class: type[WaitableEvent] = WaitableEventWrapper
+
+    def __init__(self, max_requests: int | None) -> None:
+        super().__init__()
+        self.max_requests = max_requests
+        self.requests = 0
+        self.terminate = self.event_class()
+        self.terminated = self.event_class()
+
+    async def mark_request(self) -> None:
+        if self.max_requests is None:
+            return
+
+        self.requests += 1
+        if self.requests > self.max_requests:
+            await self.terminate.set()
+
+    @staticmethod
+    async def sleep(wait: float) -> None:
+        return await anyio.sleep(wait)
+
+    @staticmethod
+    def time() -> float:
+        return anyio.current_time()
+
+
+class ShutdownError(Exception):
+    pass

omserv/server/workers.py

@@ -0,0 +1,193 @@
+import errno
+import functools
+import logging
+import os
+import random
+import signal  # noqa
+import typing as ta
+
+import anyio
+import anyio.abc
+
+from .config import Config
+from .lifespans import Lifespan
+from .sockets import Sockets
+from .sockets import create_sockets
+from .sockets import repr_socket_addr
+from .tcpserver import TcpServer
+from .types import AppWrapper
+from .types import AsgiFramework
+from .types import wrap_app
+from .workercontext import ShutdownError
+from .workercontext import WorkerContext
+
+
+log = logging.getLogger(__name__)
+
+
+async def raise_shutdown(shutdown_event: ta.Callable[..., ta.Awaitable]) -> None:
+    await shutdown_event()
+    raise ShutdownError
+
+
+# Errors that accept(2) can return, and which indicate that the system is overloaded
+ACCEPT_CAPACITY_ERRNOS = {
+    errno.EMFILE,
+    errno.ENFILE,
+    errno.ENOMEM,
+    errno.ENOBUFS,
+}
+
+
+async def _run_handler(
+        stream: anyio.abc.SocketStream,
+        handler: ta.Callable[[anyio.abc.SocketStream], ta.Awaitable],
+) -> None:
+    try:
+        await handler(stream)
+    finally:
+        await anyio.aclose_forcefully(stream)
+
+
+SLEEP_TIME = 0.100
+
+
+async def _serve_one_listener(
+        listener: anyio.abc.SocketListener,
+        handler_task_group: anyio.abc.TaskGroup,
+        handler: ta.Callable[[anyio.abc.SocketStream], ta.Awaitable],
+) -> ta.NoReturn:
+    async with listener:
+        while True:
+            try:
+                stream = await listener.accept()
+            except OSError as exc:
+                if exc.errno in ACCEPT_CAPACITY_ERRNOS:
+                    log.exception(
+                        'accept returned %s (%s); retrying in %s seconds',
+                        errno.errorcode[exc.errno],
+                        os.strerror(exc.errno),
+                        SLEEP_TIME,
+                    )
+                    await anyio.sleep(SLEEP_TIME)
+                else:
+                    raise
+            else:
+                handler_task_group.start_soon(_run_handler, stream, handler)
+
+
+async def serve_listeners(
+        handler: ta.Callable[[anyio.abc.SocketStream], ta.Awaitable],
+        listeners: ta.Iterable[anyio.abc.SocketListener],
+        *,
+        handler_task_group: anyio.abc.TaskGroup | None = None,
+        task_status: anyio.abc.TaskStatus[ta.Iterable[anyio.abc.SocketListener]] = anyio.TASK_STATUS_IGNORED,
+) -> ta.NoReturn:
+    async with anyio.create_task_group() as task_group:
+        if handler_task_group is None:
+            handler_task_group = task_group
+        for listener in listeners:
+            task_group.start_soon(_serve_one_listener, listener, handler_task_group, handler)
+        # The listeners are already queueing connections when we're called, but we wait until the end to call started()
+        # just in case we get an error or whatever.
+        task_status.started(listeners)
+
+    raise RuntimeError('unreachable')
+
+
+async def _install_signal_handler(
+        tg: anyio.abc.TaskGroup,
+) -> ta.Callable[..., ta.Awaitable[None]] | None:
+    signal_event = anyio.Event()
+
+    sigs = [
+        getattr(signal, signal_name)
+        for signal_name in ('SIGINT', 'SIGTERM', 'SIGBREAK')
+        if hasattr(signal, signal_name)
+    ]
+
+    if not sigs:
+        return None
+
+    async def _handler(*, task_status=anyio.TASK_STATUS_IGNORED):
+        with anyio.open_signal_receiver(signal.SIGINT, signal.SIGTERM) as signals:
+            task_status.started()
+            async for signum in signals:
+                if signum == signal.SIGINT:
+                    print('Ctrl+C pressed!')
+                else:
+                    print('Terminated!')
+
+                signal_event.set()
+                return
+
+    await tg.start(_handler)
+    return signal_event.wait
+
+
+async def serve(
+        app: AsgiFramework | AppWrapper,
+        config: Config,
+        *,
+        sockets: Sockets | None = None,
+        shutdown_trigger: ta.Callable[..., ta.Awaitable[None]] | None = None,
+        handle_shutdown_signals: bool = False,
+        task_status: anyio.abc.TaskStatus[ta.Sequence[str]] = anyio.TASK_STATUS_IGNORED,
+) -> None:
+    app = wrap_app(app)
+
+    lifespan = Lifespan(app, config)
+    max_requests = None
+    if config.max_requests is not None:
+        max_requests = config.max_requests + random.randint(0, config.max_requests_jitter)
+    context = WorkerContext(max_requests)
+
+    async with anyio.create_task_group() as lifespan_task_group:
+        if shutdown_trigger is None and handle_shutdown_signals:
+            shutdown_trigger = await _install_signal_handler(lifespan_task_group)
+
+        await lifespan_task_group.start(lifespan.handle_lifespan)
+        await lifespan.wait_for_startup()
+
+        async with anyio.create_task_group() as server_task_group:
+            if sockets is None:
+                sockets = create_sockets(config)
+                for sock in sockets.insecure_sockets:
+                    sock.listen(config.backlog)
+
+            listeners = []
+            binds = []
+
+            for sock in sockets.insecure_sockets:
+                listeners.append(anyio._core._eventloop.get_async_backend().create_tcp_listener(sock))  # noqa
+                bind = repr_socket_addr(sock.family, sock.getsockname())
+                binds.append(f'http://{bind}')
+                log.info('Running on http://%s (CTRL + C to quit)', bind)
+
+            task_status.started(binds)
+            try:
+                async with anyio.create_task_group() as task_group:
+                    if shutdown_trigger is not None:
+                        task_group.start_soon(raise_shutdown, shutdown_trigger)
+                    task_group.start_soon(raise_shutdown, context.terminate.wait)
+
+                    task_group.start_soon(
+                        functools.partial(
+                            serve_listeners,
+                            functools.partial(TcpServer, app, config, context),
+                            listeners,
+                            handler_task_group=server_task_group,
+                        ),
+                    )
+
+                    await anyio.sleep_forever()
+            except BaseExceptionGroup as error:
+                _, other_errors = error.split((ShutdownError, KeyboardInterrupt))  # noqa
+                if other_errors is not None:
+                    raise other_errors  # noqa
+            finally:
+                await context.terminated.set()
+                server_task_group.cancel_scope.deadline = anyio.current_time() + config.graceful_timeout
+
+        await lifespan.wait_for_shutdown()
+        lifespan_task_group.cancel_scope.cancel()

omserv-0.0.0.dev7.dist-info/LICENSE

@@ -0,0 +1,21 @@
+Copyright 2023- wrmsr
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
+following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following
+disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
+disclaimer in the documentation and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products
+derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

omserv-0.0.0.dev7.dist-info/METADATA

@@ -0,0 +1,21 @@
+Metadata-Version: 2.1
+Name: omserv
+Version: 0.0.0.dev7
+Summary: omserv
+Author: wrmsr
+License: BSD-3-Clause
+Project-URL: source, https://github.com/wrmsr/omlish
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Operating System :: POSIX
+Requires-Python: >=3.12
+License-File: LICENSE
+Requires-Dist: omlish ==0.0.0.dev7
+Provides-Extra: server
+Requires-Dist: h11 >=0.14 ; extra == 'server'
+Requires-Dist: h2 >=4.1 ; extra == 'server'
+Requires-Dist: priority >=2 ; extra == 'server'
+Requires-Dist: wsproto >=1.2 ; extra == 'server'
+

omserv-0.0.0.dev7.dist-info/RECORD

@@ -0,0 +1,44 @@
+omserv/__about__.py,sha256=SVIHOVKqN_bCysy9qjnPhoEnzysjl_l7dXo85n3rMS0,616
+omserv/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+omserv/dbs.py,sha256=RLXwNmENmM9MLsjFqDho_R8ibMjOKAxWUn4zhzTlP9Y,756
+omserv/secrets.py,sha256=ja0VsCB01MHxYwn5OHjFeXV9cRah9AQl-0uJzZELpic,256
+omserv/apps/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+omserv/apps/base.py,sha256=KSwxbC0_fY87_DucvpEOHG6gZ2wL78D-N3We8RTEU4Q,385
+omserv/apps/inject.py,sha256=RZjPcB_xEPhdw5Ki3rnKeHMqhJ8zFJZ_QZSrKpH-0xM,2670
+omserv/apps/markers.py,sha256=LBVx9LTyKB2sPqDrMHjwVpqH3xDIRqMjlFFw1HsXOWI,867
+omserv/apps/routes.py,sha256=shcN8qCSF2YoKal7nk-lemCAK3RX8MuHgNHhq_CTnh0,3762
+omserv/apps/sessions.py,sha256=glruQSbOSbCYLPp6nDRNSHCyp5hj4oiOPhh3R0F9BTM,1537
+omserv/apps/templates.py,sha256=NyCsKmPaLsGYc1mWyGiC7EcYsisQhq-wWdrnHnbwxC8,2095
+omserv/node/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+omserv/node/models.py,sha256=XsfAI-LjlRkRfK0_ofh-gai5IUq_g357UfThK9dZ0UM,1258
+omserv/node/registry.py,sha256=0hodmyQn3POOZJBG8zTr9ojR80-ZNmIwJpQbchJg8EM,3459
+omserv/node/sql.py,sha256=vy7RP50JiH3jQHMVa7Hxk0pFJK3QcbGeTvyNppB1W4I,2826
+omserv/server/__init__.py,sha256=K8l4nfv9c_5o8dph-SyadW_19CdTC2FGlikyHMU5lAU,375
+omserv/server/config.py,sha256=oGWL1kuk45bJ6sVr8n3ow5Q-1nz9EqByjoykU2iOHIY,1189
+omserv/server/debug.py,sha256=N7RI0Jj-ttmys3DJD0RREmGG5XZpTCp6y9Yu0x98Agg,299
+omserv/server/events.py,sha256=VMr_rArsVjJYnyH9SqLWtOLUg18vSu1O0ep9gNBGR_c,1369
+omserv/server/headers.py,sha256=3H-NxMMQg5WuF5wF4AWFUEqkToh4NqNqHouavzbOQok,1188
+omserv/server/lifespans.py,sha256=kRVxDQM18jCBzRUpafyb69q_bGSCyxxjAtrkxjqcZdE,4607
+omserv/server/multiprocess.py,sha256=xEQ4Na-Nej3oO_cxvYmQ1vEKtuLJNirrfRRMeKTxtVo,4377
+omserv/server/sockets.py,sha256=lwqNP7URlp605ibsjHzp0pc-lyjcyTu-hD-uyojLUYk,3389
+omserv/server/ssl.py,sha256=gmB5ecM8Mck-YtGYF8pb2dwFdjABVGzERFCDzM9lBck,1483
+omserv/server/taskspawner.py,sha256=ljzF26UPtnp7GLAY_BvjzuwCoCO9aL7TKLwRNTmUy1M,3008
+omserv/server/tcpserver.py,sha256=akC-2WOhmoIiJBH0Ti0m1uK_sOTBYGie0CoRkEcUmkA,5082
+omserv/server/types.py,sha256=XXY5py8RYlEeD4FZrWNqSyX7DD-ffSlcG-T2s9BY9eI,2017
+omserv/server/workercontext.py,sha256=4rcLuGsyiU7URO7T_eHylOBPPNUS9C23QfEUVyJUtIY,1200
+omserv/server/workers.py,sha256=rdV8qEzWKMZ6HnN9nUoGS58U9LRsrsqOcAd_7yl73Y0,6586
+omserv/server/protocols/__init__.py,sha256=Ryu2PDZ1TUI6F2l-HBEYgyzZ7wHqE6VmjqnS0tIvmQI,47
+omserv/server/protocols/h11.py,sha256=ctakfp8fyI2opzIWzwV1FGlnJlWL3QkMABp-qoPYFXI,12050
+omserv/server/protocols/h2.py,sha256=pClkPlaX0WnQ1dKee7Fvr4csSH2bBqItTcsKVuk1p1Q,15297
+omserv/server/protocols/protocols.py,sha256=1ky8PGYIIR8wco6fcw-41RmHW-Kz_cNcZZoOqi7btNk,2790
+omserv/server/protocols/types.py,sha256=OXt5U3LsBToDxT7ipfFGiIHJU0WVvlfT6QQacF-_Plc,440
+omserv/server/resources/__init__.py,sha256=KppZbvZBKX1TdyaQZYY92oEKpdB3nuUXxharAgrbAIA,193
+omserv/server/streams/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+omserv/server/streams/httpstream.py,sha256=0DeiAPLGbEGNa0fHTs8lUpi_CFZs4M5_QB-TiS8mobQ,8015
+omserv/server/streams/utils.py,sha256=aMOrqWIg_Hht5W4kLg3y7oR5AEkVvMrZhyjzo6U5owE,1527
+omserv/server/streams/wsstream.py,sha256=3Vyzox7dCE1tDSXjb6xBubWo41ZF9d38Hrsrlj6h1J8,15482
+omserv-0.0.0.dev7.dist-info/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
+omserv-0.0.0.dev7.dist-info/METADATA,sha256=Y7anWoLnYvQ2eCXsmCjKdXGMIApFW1sKmz0ebI1OG64,680
+omserv-0.0.0.dev7.dist-info/WHEEL,sha256=Mdi9PDNwEZptOjTlUcAth7XJDFtKrHYaQMPulZeBCiQ,91
+omserv-0.0.0.dev7.dist-info/top_level.txt,sha256=HXehpnxeKscKNULzKNzZ27oNawBrsh1PaNAirbX-XNA,7
+omserv-0.0.0.dev7.dist-info/RECORD,,

omserv-0.0.0.dev7.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (73.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

omserv-0.0.0.dev7.dist-info/top_level.txt

@@ -0,0 +1 @@
+omserv