seamless-jobserver 0.1.0__tar.gz

seamless_jobserver-0.1.0/PKG-INFO

@@ -0,0 +1,99 @@
+Metadata-Version: 2.4
+Name: seamless-jobserver
+Version: 0.1.0
+Summary: Jobserver service for asynchronous Seamless transformation execution
+Author: Sjoerd de Vries
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/sjdv1982/seamless
+Project-URL: Repository, https://github.com/sjdv1982/seamless
+Project-URL: Issues, https://github.com/sjdv1982/seamless/issues
+Keywords: seamless,jobserver,transformations,service
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: aiohttp
+Requires-Dist: seamless-core
+Requires-Dist: seamless-config
+Requires-Dist: seamless-remote
+Requires-Dist: seamless-transformer
+
+# seamless-jobserver
+
+`seamless-jobserver` is a lightweight async HTTP service in the [Seamless](https://github.com/sjdv1982/seamless) ecosystem. It receives transformation jobs over HTTP, dispatches them to spawned Seamless worker processes, and returns the results. It is one of the four backend services that `seamless-remote` connects to.
+
+**This is a standalone service, not a library.** User workflow code never imports `seamless-jobserver` — it runs as an independent process, normally launched by `seamless-config` via `remote-http-launcher`. The only user-facing entry point is the `seamless-jobserver` CLI command.
+
+## How it works
+
+The jobserver is a single-module (`jobserver.py`) aiohttp server. On startup it spawns a pool of Seamless worker processes (via `seamless-transformer`). Incoming transformation requests arrive over HTTP, are dispatched to the worker pool, and results are returned to the caller — which is always `seamless-remote`'s `jobserver_remote` module, never user code directly.
+
+### HTTP endpoints
+
+| Endpoint | Method | Description |
+| --- | --- | --- |
+| `/` | GET | Welcome / version check |
+| `/healthcheck` | GET | Liveness probe |
+| `/run-transformation` | GET | Execute a transformation and return the result checksum |
+
+### Lifecycle
+
+1. `seamless-config` writes a status file and launches `seamless-jobserver` (via `remote-http-launcher` or directly).
+2. The jobserver picks a port (fixed or random from a range), spawns worker processes, and starts listening.
+3. It writes its port and status back to the status file so `seamless-remote` can discover it.
+4. If no requests arrive within the inactivity timeout, the jobserver shuts down automatically.
+
+---
+
+## Relation to the Seamless ecosystem
+
+```text
+    seamless-transformer                (user-facing API: direct, delayed)
+        │
+        │  delegate job
+        ▼
+    seamless-remote
+        │  jobserver_remote
+        │  async HTTP
+        ▼
+    seamless-jobserver                 ◄── this package
+        │
+        │  dispatches to worker pool
+        ▼
+    seamless-transformer worker        (spawned child processes)
+```
+
+The jobserver sits between `seamless-remote` (which sends it work) and `seamless-transformer` (whose worker processes do the actual computation). It is a simpler, single-machine alternative to the Dask-based execution path provided by `seamless-dask`.
+
+---
+
+## CLI
+
+```bash
+seamless-jobserver [options]
+```
+
+| Flag | Default | Description |
+| --- | --- | --- |
+| `--port PORT` | — | Listen on a specific port (mutually exclusive with `--port-range`) |
+| `--port-range START END` | — | Pick a random free port from a range |
+| `--host HOST` | `0.0.0.0` | Listening address |
+| `--status-file PATH` | — | JSON file for reporting port and status |
+| `--timeout SECONDS` | — | Auto-shutdown after this many seconds of inactivity |
+| `--workers N` | `1` | Number of worker processes to spawn |
+
+---
+
+## Installation
+
+```bash
+pip install seamless-jobserver
+```
+
+Requires Python >= 3.10. Dependencies: `aiohttp`, `seamless-core`, `seamless-transformer`. Also imports `seamless-remote` and `seamless-config` at runtime for client cleanup and remote-client configuration respectively.

seamless_jobserver-0.1.0/README.md

@@ -0,0 +1,73 @@
+# seamless-jobserver
+
+`seamless-jobserver` is a lightweight async HTTP service in the [Seamless](https://github.com/sjdv1982/seamless) ecosystem. It receives transformation jobs over HTTP, dispatches them to spawned Seamless worker processes, and returns the results. It is one of the four backend services that `seamless-remote` connects to.
+
+**This is a standalone service, not a library.** User workflow code never imports `seamless-jobserver` — it runs as an independent process, normally launched by `seamless-config` via `remote-http-launcher`. The only user-facing entry point is the `seamless-jobserver` CLI command.
+
+## How it works
+
+The jobserver is a single-module (`jobserver.py`) aiohttp server. On startup it spawns a pool of Seamless worker processes (via `seamless-transformer`). Incoming transformation requests arrive over HTTP, are dispatched to the worker pool, and results are returned to the caller — which is always `seamless-remote`'s `jobserver_remote` module, never user code directly.
+
+### HTTP endpoints
+
+| Endpoint | Method | Description |
+| --- | --- | --- |
+| `/` | GET | Welcome / version check |
+| `/healthcheck` | GET | Liveness probe |
+| `/run-transformation` | GET | Execute a transformation and return the result checksum |
+
+### Lifecycle
+
+1. `seamless-config` writes a status file and launches `seamless-jobserver` (via `remote-http-launcher` or directly).
+2. The jobserver picks a port (fixed or random from a range), spawns worker processes, and starts listening.
+3. It writes its port and status back to the status file so `seamless-remote` can discover it.
+4. If no requests arrive within the inactivity timeout, the jobserver shuts down automatically.
+
+---
+
+## Relation to the Seamless ecosystem
+
+```text
+    seamless-transformer                (user-facing API: direct, delayed)
+        │
+        │  delegate job
+        ▼
+    seamless-remote
+        │  jobserver_remote
+        │  async HTTP
+        ▼
+    seamless-jobserver                 ◄── this package
+        │
+        │  dispatches to worker pool
+        ▼
+    seamless-transformer worker        (spawned child processes)
+```
+
+The jobserver sits between `seamless-remote` (which sends it work) and `seamless-transformer` (whose worker processes do the actual computation). It is a simpler, single-machine alternative to the Dask-based execution path provided by `seamless-dask`.
+
+---
+
+## CLI
+
+```bash
+seamless-jobserver [options]
+```
+
+| Flag | Default | Description |
+| --- | --- | --- |
+| `--port PORT` | — | Listen on a specific port (mutually exclusive with `--port-range`) |
+| `--port-range START END` | — | Pick a random free port from a range |
+| `--host HOST` | `0.0.0.0` | Listening address |
+| `--status-file PATH` | — | JSON file for reporting port and status |
+| `--timeout SECONDS` | — | Auto-shutdown after this many seconds of inactivity |
+| `--workers N` | `1` | Number of worker processes to spawn |
+
+---
+
+## Installation
+
+```bash
+pip install seamless-jobserver
+```
+
+Requires Python >= 3.10. Dependencies: `aiohttp`, `seamless-core`, `seamless-transformer`. Also imports `seamless-remote` and `seamless-config` at runtime for client cleanup and remote-client configuration respectively.

seamless_jobserver-0.1.0/jobserver.py

@@ -0,0 +1,376 @@
+from aiohttp import web
+import asyncio
+import contextlib
+import json
+import os
+import random
+import signal
+import socket
+import sys
+import time
+
+from seamless import Checksum, Buffer
+from seamless.transformer import spawn
+from seamless_transformer import worker
+import seamless
+from seamless.util.get_event_loop import get_event_loop
+
+try:
+    from seamless_remote.client import close_all_clients as _close_all_clients
+except ImportError:
+    _close_all_clients = None
+
+
+STATUS_FILE_WAIT_TIMEOUT = 20.0
+INACTIVITY_CHECK_INTERVAL = 1.0
+
+status_tracker = None
+
+
+def is_port_in_use(address, port):
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        return s.connect_ex((address, port)) == 0
+
+
+def wait_for_status_file(path: str, timeout: float = STATUS_FILE_WAIT_TIMEOUT):
+    deadline = time.monotonic() + timeout
+    while True:
+        try:
+            with open(path, "r", encoding="utf-8") as status_stream:
+                contents = json.load(status_stream)
+                break
+        except FileNotFoundError:
+            if time.monotonic() >= deadline:
+                print(
+                    f"Status file '{path}' not found after {int(timeout)} seconds",
+                    file=sys.stderr,
+                )
+                sys.exit(1)
+            time.sleep(0.1)
+            continue
+        except json.JSONDecodeError as exc:
+            print(
+                f"Status file '{path}' is not valid JSON: {exc}",
+                file=sys.stderr,
+            )
+            sys.exit(1)
+
+    if not isinstance(contents, dict):
+        print(
+            f"Status file '{path}' must contain a JSON object",
+            file=sys.stderr,
+        )
+        sys.exit(1)
+
+    return contents
+
+
+class StatusFileTracker:
+    def __init__(self, path: str, base_contents: dict, port: int):
+        self.path = path
+        self._base_contents = dict(base_contents)
+        self.port = port
+        self.running_written = False
+
+    def _write(self, payload: dict):
+        tmp_path = f"{self.path}.tmp"
+        with open(tmp_path, "w", encoding="utf-8") as status_stream:
+            json.dump(payload, status_stream)
+            status_stream.write("\n")
+        os.replace(tmp_path, self.path)
+
+    def write_running(self):
+        payload = dict(self._base_contents)
+        payload["port"] = self.port
+        payload["status"] = "running"
+        self._write(payload)
+        self._base_contents = payload
+        self.running_written = True
+
+    def write_failed(self):
+        payload = dict(self._base_contents)
+        payload["status"] = "failed"
+        self._write(payload)
+
+
+def raise_startup_error(exc: BaseException):
+    if status_tracker and not status_tracker.running_written:
+        status_tracker.write_failed()
+    raise exc
+
+
+def pick_random_free_port(host: str, start: int, end: int) -> int:
+    if start < 0 or end > 65535:
+        raise RuntimeError("--port-range values must be between 0 and 65535")
+    if start > end:
+        raise RuntimeError("--port-range START must be less than or equal to END")
+
+    span = end - start + 1
+    attempted = set()
+    while len(attempted) < span:
+        port = random.randint(start, end)
+        if port in attempted:
+            continue
+        attempted.add(port)
+        try:
+            with socket.create_server((host, port), reuse_port=False):
+                pass
+        except OSError:
+            continue
+        return port
+
+    raise RuntimeError(f"No free port available in range {start}-{end}")
+
+
+class JobServer:
+    future = None
+
+    def __init__(
+        self,
+        host,
+        port,
+        *,
+        timeout_seconds=None,
+        status_tracker=None,
+    ):
+        self.host = host
+        self.port = port
+        self._timeout_seconds = timeout_seconds
+        self._status_tracker = status_tracker
+        self._timeout_task = None
+        self._last_request = None
+        self._runner = None
+        self._site = None
+
+    async def _start(self):
+        if is_port_in_use(self.host, self.port):
+            print("ERROR: %s port %d already in use" % (self.host, self.port))
+            raise Exception
+
+        app = web.Application(client_max_size=10e9)
+        app.add_routes(
+            [
+                web.get("/", self._welcome),
+                web.get("/healthcheck", self._healthcheck),
+                web.get("/run-transformation", self._run_transformation),
+            ]
+        )
+        runner = web.AppRunner(app)
+        await runner.setup()
+        site = web.TCPSite(runner, self.host, self.port)
+        await site.start()
+        self._runner = runner
+        self._site = site
+        if self._status_tracker and not self._status_tracker.running_written:
+            self._status_tracker.write_running()
+        print(f"Welcome to the Seamless jobserver on {self.host}:{self.port}")
+        sys.stdout.flush()
+        if self._timeout_seconds is not None:
+            self._last_request = time.monotonic()
+            loop = asyncio.get_running_loop()
+            self._timeout_task = loop.create_task(self._monitor_inactivity())
+
+    def start(self):
+        if self.future is not None:
+            return
+        loop = get_event_loop()
+        if loop.is_closed():
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+        coro = self._start()
+        self.future = loop.create_task(coro)
+
+    async def stop(self):
+        if self._timeout_task:
+            self._timeout_task.cancel()
+            with contextlib.suppress(asyncio.CancelledError):
+                await self._timeout_task
+            self._timeout_task = None
+        if self._site is not None:
+            await self._site.stop()
+            self._site = None
+        if self._runner is not None:
+            await self._runner.cleanup()
+            self._runner = None
+
+    async def _monitor_inactivity(self):
+        try:
+            while True:
+                await asyncio.sleep(INACTIVITY_CHECK_INTERVAL)
+                if self._last_request is None:
+                    continue
+                if time.monotonic() - self._last_request >= self._timeout_seconds:
+                    loop = asyncio.get_running_loop()
+                    loop.call_soon(loop.stop)
+                    break
+        except asyncio.CancelledError:
+            raise
+
+    def _register_activity(self):
+        if self._timeout_seconds is not None:
+            self._last_request = time.monotonic()
+
+    async def _healthcheck(self, _):
+        self._register_activity()
+        return web.Response(status=200, body="OK")
+
+    async def _welcome(self, _):
+        self._register_activity()
+        return web.Response(status=200, body="Seamless jobserver is running")
+
+    async def _run_transformation(self, request):
+        self._register_activity()
+        try:
+            payload = await request.json()
+        except Exception as exc:
+            return web.Response(status=400, text=f"Invalid JSON: {exc}")
+
+        try:
+            transformation_dict = payload["transformation_dict"]
+            tf_checksum = Checksum(payload["tf_checksum"])
+            tf_dunder = payload.get("tf_dunder", {})
+            scratch = bool(payload.get("scratch", False))
+        except Exception as exc:
+            return web.Response(status=400, text=f"Invalid payload: {exc}")
+
+        tf_checksum_hex = tf_checksum.hex()
+        print(f"[jobserver] Received transformation {tf_checksum_hex}", flush=True)
+        try:
+            result_checksum = await worker.dispatch_to_workers(
+                transformation_dict,
+                tf_checksum=tf_checksum,
+                tf_dunder=tf_dunder,
+                scratch=scratch,
+            )
+        except Exception as exc:
+            return web.Response(status=500, text=str(exc))
+
+        if isinstance(result_checksum, str):
+            return web.Response(status=500, text=result_checksum)
+
+        result_checksum = Checksum(result_checksum)
+        if not scratch:
+            result_buf = await result_checksum.resolution()
+            assert isinstance(result_buf, Buffer)
+        print(
+            f"[jobserver] Completed transformation {tf_checksum_hex} -> {result_checksum.hex()}",
+            flush=True,
+        )
+        return web.Response(status=200, text=result_checksum.hex())
+
+
+def main():
+    import argparse
+
+    p = argparse.ArgumentParser()
+    port_group = p.add_mutually_exclusive_group()
+    port_group.add_argument("--port", type=int, help="Network port")
+    port_group.add_argument(
+        "--port-range",
+        type=int,
+        nargs=2,
+        metavar=("START", "END"),
+        help="Inclusive port range to select a random free port from",
+    )
+    p.add_argument("--host", default="0.0.0.0")
+    p.add_argument(
+        "--status-file",
+        type=str,
+        help="JSON file used to report server status",
+    )
+    p.add_argument(
+        "--timeout",
+        type=float,
+        help="Stop the server after this many seconds of inactivity",
+    )
+    p.add_argument(
+        "--workers",
+        type=int,
+        default=1,
+        help="Number of worker processes to spawn",
+    )
+    args = p.parse_args()
+
+    global status_tracker
+
+    selected_port = args.port if args.port is not None else 5533
+    status_file_path = args.status_file
+    status_tracker = None
+    parameters = {}
+    if status_file_path:
+        status_file_contents = wait_for_status_file(status_file_path)
+        parameters = status_file_contents.get("parameters", {}) or {}
+        status_tracker = StatusFileTracker(
+            status_file_path, status_file_contents, args.port
+        )
+
+    if args.port_range:
+        start, end = args.port_range
+        try:
+            selected_port = pick_random_free_port(args.host, start, end)
+        except BaseException as exc:
+            raise_startup_error(exc)
+    if status_tracker:
+        status_tracker.port = selected_port
+
+    timeout_seconds = args.timeout
+    if timeout_seconds is not None and timeout_seconds <= 0:
+        raise_startup_error(RuntimeError("--timeout must be a positive number"))
+    if args.workers is not None and args.workers <= 0:
+        raise_startup_error(RuntimeError("--workers must be a positive integer"))
+
+    def raise_system_exit(*args, **kwargs):
+        raise SystemExit
+
+    signal.signal(signal.SIGTERM, raise_system_exit)
+    signal.signal(signal.SIGHUP, raise_system_exit)
+    signal.signal(signal.SIGINT, raise_system_exit)
+
+    try:
+        spawn(args.workers)
+        if parameters:
+            from seamless.config import set_remote_clients
+
+            set_remote_clients(parameters)
+    except BaseException as exc:
+        raise_startup_error(exc)
+
+    job_server = JobServer(
+        args.host,
+        selected_port,
+        timeout_seconds=timeout_seconds,
+        status_tracker=status_tracker,
+    )
+    job_server.start()
+
+    loop = get_event_loop()
+    try:
+        loop.run_forever()
+    except KeyboardInterrupt:
+        pass
+    except BaseException:
+        if status_tracker and not status_tracker.running_written:
+            status_tracker.write_failed()
+        raise
+    finally:
+        loop.run_until_complete(job_server.stop())
+        closed_ok = False
+        try:
+            seamless.close()
+            closed_ok = True
+        except Exception:
+            pass
+        if not closed_ok:
+            try:
+                worker.shutdown_workers()
+            except Exception:
+                pass
+            if _close_all_clients is not None:
+                try:
+                    _close_all_clients()
+                except Exception:
+                    pass
+
+
+if __name__ == "__main__":
+    main()

seamless_jobserver-0.1.0/pyproject.toml

@@ -0,0 +1,41 @@
+[build-system]
+requires = ["setuptools>=69", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "seamless-jobserver"
+version = "0.1.0"
+description = "Jobserver service for asynchronous Seamless transformation execution"
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+authors = [{name = "Sjoerd de Vries"}]
+dependencies = [
+    "aiohttp",
+    "seamless-core",
+    "seamless-config",
+    "seamless-remote",
+    "seamless-transformer",
+]
+keywords = ["seamless", "jobserver", "transformations", "service"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Science/Research",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Operating System :: OS Independent",
+    "Topic :: Scientific/Engineering",
+    "Topic :: Software Development :: Libraries",
+]
+
+[project.urls]
+Homepage = "https://github.com/sjdv1982/seamless"
+Repository = "https://github.com/sjdv1982/seamless"
+Issues = "https://github.com/sjdv1982/seamless/issues"
+
+[project.scripts]
+seamless-jobserver = "jobserver:main"
+
+[tool.setuptools]
+py-modules = ["jobserver"]

seamless_jobserver-0.1.0/seamless_jobserver.egg-info/PKG-INFO

@@ -0,0 +1,99 @@
+Metadata-Version: 2.4
+Name: seamless-jobserver
+Version: 0.1.0
+Summary: Jobserver service for asynchronous Seamless transformation execution
+Author: Sjoerd de Vries
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/sjdv1982/seamless
+Project-URL: Repository, https://github.com/sjdv1982/seamless
+Project-URL: Issues, https://github.com/sjdv1982/seamless/issues
+Keywords: seamless,jobserver,transformations,service
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: aiohttp
+Requires-Dist: seamless-core
+Requires-Dist: seamless-config
+Requires-Dist: seamless-remote
+Requires-Dist: seamless-transformer
+
+# seamless-jobserver
+
+`seamless-jobserver` is a lightweight async HTTP service in the [Seamless](https://github.com/sjdv1982/seamless) ecosystem. It receives transformation jobs over HTTP, dispatches them to spawned Seamless worker processes, and returns the results. It is one of the four backend services that `seamless-remote` connects to.
+
+**This is a standalone service, not a library.** User workflow code never imports `seamless-jobserver` — it runs as an independent process, normally launched by `seamless-config` via `remote-http-launcher`. The only user-facing entry point is the `seamless-jobserver` CLI command.
+
+## How it works
+
+The jobserver is a single-module (`jobserver.py`) aiohttp server. On startup it spawns a pool of Seamless worker processes (via `seamless-transformer`). Incoming transformation requests arrive over HTTP, are dispatched to the worker pool, and results are returned to the caller — which is always `seamless-remote`'s `jobserver_remote` module, never user code directly.
+
+### HTTP endpoints
+
+| Endpoint | Method | Description |
+| --- | --- | --- |
+| `/` | GET | Welcome / version check |
+| `/healthcheck` | GET | Liveness probe |
+| `/run-transformation` | GET | Execute a transformation and return the result checksum |
+
+### Lifecycle
+
+1. `seamless-config` writes a status file and launches `seamless-jobserver` (via `remote-http-launcher` or directly).
+2. The jobserver picks a port (fixed or random from a range), spawns worker processes, and starts listening.
+3. It writes its port and status back to the status file so `seamless-remote` can discover it.
+4. If no requests arrive within the inactivity timeout, the jobserver shuts down automatically.
+
+---
+
+## Relation to the Seamless ecosystem
+
+```text
+    seamless-transformer                (user-facing API: direct, delayed)
+        │
+        │  delegate job
+        ▼
+    seamless-remote
+        │  jobserver_remote
+        │  async HTTP
+        ▼
+    seamless-jobserver                 ◄── this package
+        │
+        │  dispatches to worker pool
+        ▼
+    seamless-transformer worker        (spawned child processes)
+```
+
+The jobserver sits between `seamless-remote` (which sends it work) and `seamless-transformer` (whose worker processes do the actual computation). It is a simpler, single-machine alternative to the Dask-based execution path provided by `seamless-dask`.
+
+---
+
+## CLI
+
+```bash
+seamless-jobserver [options]
+```
+
+| Flag | Default | Description |
+| --- | --- | --- |
+| `--port PORT` | — | Listen on a specific port (mutually exclusive with `--port-range`) |
+| `--port-range START END` | — | Pick a random free port from a range |
+| `--host HOST` | `0.0.0.0` | Listening address |
+| `--status-file PATH` | — | JSON file for reporting port and status |
+| `--timeout SECONDS` | — | Auto-shutdown after this many seconds of inactivity |
+| `--workers N` | `1` | Number of worker processes to spawn |
+
+---
+
+## Installation
+
+```bash
+pip install seamless-jobserver
+```
+
+Requires Python >= 3.10. Dependencies: `aiohttp`, `seamless-core`, `seamless-transformer`. Also imports `seamless-remote` and `seamless-config` at runtime for client cleanup and remote-client configuration respectively.

seamless_jobserver-0.1.0/seamless_jobserver.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+README.md
+jobserver.py
+pyproject.toml
+seamless_jobserver.egg-info/PKG-INFO
+seamless_jobserver.egg-info/SOURCES.txt
+seamless_jobserver.egg-info/dependency_links.txt
+seamless_jobserver.egg-info/entry_points.txt
+seamless_jobserver.egg-info/requires.txt
+seamless_jobserver.egg-info/top_level.txt

seamless_jobserver-0.1.0/seamless_jobserver.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

seamless_jobserver-0.1.0/seamless_jobserver.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+seamless-jobserver = jobserver:main

seamless_jobserver-0.1.0/seamless_jobserver.egg-info/requires.txt

@@ -0,0 +1,5 @@
+aiohttp
+seamless-core
+seamless-config
+seamless-remote
+seamless-transformer

seamless_jobserver-0.1.0/seamless_jobserver.egg-info/top_level.txt

@@ -0,0 +1 @@
+jobserver

seamless_jobserver-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+