servelive 0.1.0__tar.gz

servelive-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Reymart Centeno
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

servelive-0.1.0/PKG-INFO

@@ -0,0 +1,75 @@
+Metadata-Version: 2.4
+Name: servelive
+Version: 0.1.0
+Summary: Static file server with no-cache headers and inotify-driven live reload over SSE
+Author-email: Reymart Centeno <reymartcenteno03@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/groovyrey/servelive
+Classifier: Environment :: Web Environment
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Internet :: WWW/HTTP :: HTTP Servers
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Dynamic: license-file
+
+# servelive
+
+A static file server with no-cache headers and live reload, powered by Linux
+inotify and Server-Sent Events. A drop-in replacement for `python3 -m http.server`
+that refreshes the browser the moment a served file changes. No polling anywhere,
+and no third-party dependencies (pure Python standard library + the system libc).
+
+## Features
+
+- No-cache headers on every response so dev browsers always fetch fresh files
+- Live reload via **inotify** (real file-change detection) + **SSE** push
+- Serves over the network by default (`0.0.0.0`) and prints your LAN address
+- Degrades gracefully on systems without inotify (survives, just no reload)
+
+## Install
+
+```bash
+pip install servelive
+```
+
+## Usage
+
+```bash
+servelive                 # serve ./ on port 8000
+servelive 8500            # serve ./ on port 8500
+servelive 8500 ./site     # serve ./site on port 8500
+servelive --bind 127.0.0.1 9000   # localhost only
+```
+
+Startup output mirrors a JS dev server:
+
+```
+  local:   http://localhost:8000/
+  network: http://192.168.100.167:8000/
+  serving /home/you/site (live reload via inotify)
+```
+
+Open the `local:` or `network:` URL in a browser, edit any file under the served
+directory, and the page reloads itself.
+
+## How it works
+
+1. A background thread watches the served tree with the Linux `inotify` API
+   (called through `ctypes`, stdlib only).
+2. On a change, an 80 ms debounce coalesces the raw event burst into a single
+   notification.
+3. The server broadcasts a reload over an SSE stream to every connected page.
+
+The reload script is injected into served HTML, so any page you open through
+`servelive` gets live reload automatically.
+
+## License
+
+MIT

servelive-0.1.0/README.md

@@ -0,0 +1,54 @@
+# servelive
+
+A static file server with no-cache headers and live reload, powered by Linux
+inotify and Server-Sent Events. A drop-in replacement for `python3 -m http.server`
+that refreshes the browser the moment a served file changes. No polling anywhere,
+and no third-party dependencies (pure Python standard library + the system libc).
+
+## Features
+
+- No-cache headers on every response so dev browsers always fetch fresh files
+- Live reload via **inotify** (real file-change detection) + **SSE** push
+- Serves over the network by default (`0.0.0.0`) and prints your LAN address
+- Degrades gracefully on systems without inotify (survives, just no reload)
+
+## Install
+
+```bash
+pip install servelive
+```
+
+## Usage
+
+```bash
+servelive                 # serve ./ on port 8000
+servelive 8500            # serve ./ on port 8500
+servelive 8500 ./site     # serve ./site on port 8500
+servelive --bind 127.0.0.1 9000   # localhost only
+```
+
+Startup output mirrors a JS dev server:
+
+```
+  local:   http://localhost:8000/
+  network: http://192.168.100.167:8000/
+  serving /home/you/site (live reload via inotify)
+```
+
+Open the `local:` or `network:` URL in a browser, edit any file under the served
+directory, and the page reloads itself.
+
+## How it works
+
+1. A background thread watches the served tree with the Linux `inotify` API
+   (called through `ctypes`, stdlib only).
+2. On a change, an 80 ms debounce coalesces the raw event burst into a single
+   notification.
+3. The server broadcasts a reload over an SSE stream to every connected page.
+
+The reload script is injected into served HTML, so any page you open through
+`servelive` gets live reload automatically.
+
+## License
+
+MIT

servelive-0.1.0/pyproject.toml

@@ -0,0 +1,32 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "servelive"
+version = "0.1.0"
+description = "Static file server with no-cache headers and inotify-driven live reload over SSE"
+readme = "README.md"
+requires-python = ">=3.8"
+license = { text = "MIT" }
+authors = [{ name = "Reymart Centeno", email = "reymartcenteno03@gmail.com" }]
+classifiers = [
+    "Environment :: Web Environment",
+    "Intended Audience :: Developers",
+    "Operating System :: POSIX :: Linux",
+    "Programming Language :: Python :: 3",
+    "Topic :: Internet :: WWW/HTTP :: HTTP Servers",
+]
+# No runtime dependencies: pure stdlib (ctypes inotify, http.server).
+
+[project.urls]
+Homepage = "https://github.com/groovyrey/servelive"
+
+[project.scripts]
+servelive = "servelive.cli:main"
+
+[project.optional-dependencies]
+dev = ["pytest", "build", "twine"]
+
+[tool.setuptools.packages.find]
+where = ["src"]

servelive-0.1.0/setup.cfg

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

servelive-0.1.0/src/servelive/__init__.py

@@ -0,0 +1,14 @@
+"""servelive - static file server with inotify-driven live reload.
+
+A drop-in replacement for ``python3 -m http.server`` that sends
+``Cache-Control: no-store`` so dev browsers always fetch fresh files, and
+pushes an SSE "reload" event to connected pages whenever a served file changes.
+File changes are detected with Linux inotify (via ctypes, no third-party
+dependencies) so there is no polling anywhere.
+"""
+
+from servelive.server import create_server
+from servelive.cli import main
+from servelive._version import __version__
+
+__all__ = ["create_server", "main", "__version__"]

servelive-0.1.0/src/servelive/__main__.py

@@ -0,0 +1,4 @@
+from servelive.cli import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

servelive-0.1.0/src/servelive/_version.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

servelive-0.1.0/src/servelive/cli.py

@@ -0,0 +1,98 @@
+"""Command-line entry point for servelive."""
+
+import argparse
+import socket
+import subprocess
+import sys
+
+from servelive._version import __version__
+from servelive.server import LiveServer
+from servelive.watcher import is_watchable
+
+
+def lan_ip():
+    """Determine the primary non-loopback IPv4 address on this host."""
+    try:
+        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        try:
+            s.connect(("8.8.8.8", 80))
+            ip = s.getsockname()[0]
+        finally:
+            s.close()
+        if ip and not ip.startswith("127."):
+            return ip
+    except OSError:
+        pass
+    try:
+        out = subprocess.run(
+            ["ip", "-4", "addr", "show", "scope", "global"],
+            capture_output=True, text=True,
+        ).stdout
+        for line in out.splitlines():
+            line = line.strip()
+            if line.startswith("inet "):
+                ip = line.split()[1].split("/")[0]
+                if not ip.startswith("127."):
+                    return ip
+    except Exception:
+        pass
+    return None
+
+
+def build_parser():
+    parser = argparse.ArgumentParser(
+        prog="servelive",
+        description="Static file server with no-cache headers and inotify-driven live reload.",
+    )
+    parser.add_argument(
+        "port", nargs="?", type=int, default=8000,
+        help="Port to bind (default: 8000).",
+    )
+    parser.add_argument(
+        "directory", nargs="?", default=".",
+        help="Directory to serve (default: current directory).",
+    )
+    parser.add_argument(
+        "--bind", "-b", default="0.0.0.0",
+        help="Address to bind (default: 0.0.0.0 so other devices can connect).",
+    )
+    parser.add_argument(
+        "--version", action="version", version=f"servelive {__version__}",
+    )
+    return parser
+
+
+def main(argv=None):
+    args = build_parser().parse_args(argv)
+
+    if not (1 <= args.port <= 65535):
+        print(f"error: invalid port {args.port}", file=sys.stderr)
+        return 2
+
+    server = LiveServer(directory=args.directory, port=args.port)
+
+    watcher = "inotify" if is_watchable() else "none"
+    if watcher == "none":
+        print("warning: inotify unavailable - live reload disabled", file=sys.stderr)
+
+    try:
+        server.start()
+    except OSError as e:
+        print(f"error: could not bind {args.bind}:{args.port} ({e})", file=sys.stderr)
+        return 1
+
+    live = "live reload via inotify" if watcher == "inotify" else "live reload disabled"
+    local_host = "127.0.0.1" if args.bind not in ("0.0.0.0", "") else "localhost"
+    print(f"  local:   http://{local_host}:{args.port}/", flush=True)
+    if args.bind in ("0.0.0.0", ""):
+        nip = lan_ip()
+        if nip:
+            print(f"  network: http://{nip}:{args.port}/", flush=True)
+    print(f"  serving {server.directory} ({live})", flush=True)
+
+    server.serve_forever()
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

servelive-0.1.0/src/servelive/server.py

@@ -0,0 +1,168 @@
+"""The static HTTP server with no-cache headers and SSE live reload."""
+
+import functools
+import http.server
+import io
+import os
+import socketserver
+import threading
+
+from servelive.watcher import is_watchable, Watcher
+
+LIVE_RELOAD = b"""<script>
+(function () {
+  try {
+    var es = new EventSource(location.origin + "/__servelive_reload", { withCredentials: false });
+    es.onmessage = function (e) {
+      if (e.data === "reload") location.reload();
+    };
+    es.onerror = function () { es.close(); };
+  } catch (e) {}
+})();
+</script>
+"""
+
+RELOAD_PATH = "/__servelive_reload"
+
+
+class ReloadHub:
+    """Fan-out reload notifications to connected SSE clients."""
+
+    def __init__(self):
+        self._clients = []
+        self._lock = threading.Lock()
+
+    def add(self, event):
+        with self._lock:
+            self._clients.append(event)
+        return self._remove_client
+
+    def _remove_client(self, event):
+        with self._lock:
+            if event in self._clients:
+                self._clients.remove(event)
+
+    def broadcast(self):
+        with self._lock:
+            clients = list(self._clients)
+        for ev in clients:
+            ev.set()
+
+
+class _SSEEvent(threading.Event):
+    pass
+
+
+def sse_body(hub):
+    yield b"retry: 1000\n\n"
+    ev = _SSEEvent()
+    detach = hub.add(ev)
+    try:
+        while True:
+            if ev.wait(25):
+                ev.clear()
+                yield b"data: reload\n\n"
+    finally:
+        detach()
+
+
+class NoCacheHandler(http.server.SimpleHTTPRequestHandler):
+    server_version = "servelive/1.1"
+
+    def end_headers(self):
+        self.send_header("Cache-Control", "no-store, no-cache, must-revalidate")
+        self.send_header("Pragma", "no-cache")
+        self.send_header("Expires", "0")
+        super().end_headers()
+
+    def do_GET(self):
+        if self.path.rstrip("/").endswith(RELOAD_PATH):
+            try:
+                self.send_response(200)
+                self.send_header("Content-Type", "text/event-stream")
+                self.send_header("Cache-Control", "no-cache")
+                self.send_header("Connection", "keep-alive")
+                self.send_header("X-Accel-Buffering", "no")
+                self.send_header("Access-Control-Allow-Origin", "*")
+                self.end_headers()
+                for chunk in sse_body(self.server.hub):
+                    try:
+                        self.wfile.write(chunk)
+                        self.wfile.flush()
+                    except (BrokenPipeError, ConnectionResetError, OSError):
+                        break
+            except (BrokenPipeError, ConnectionResetError, OSError):
+                pass
+            return
+        return super().do_GET()
+
+    def send_head(self):
+        path = self.translate_path(self.path)
+        if os.path.isdir(path):
+            path = os.path.join(path, "index.html")
+        ctype = self.guess_type(path)
+        if ctype == "text/html" and os.path.exists(path):
+            try:
+                with open(path, "rb") as f:
+                    html = f.read()
+                html = inject_reload_script(html)
+                self.send_response(200)
+                self.send_header("Content-Type", ctype or "text/html")
+                self.send_header("Content-Length", str(len(html)))
+                self.send_header("Last-Modified", self.date_time_string())
+                self.end_headers()
+                return io.BytesIO(html)
+            except OSError:
+                pass
+        return super().send_head()
+
+
+def inject_reload_script(html):
+    if b"</body>" in html:
+        return html.replace(b"</body>", LIVE_RELOAD + b"</body>")
+    return html + LIVE_RELOAD
+
+
+class ThreadingHTTPServer(socketserver.ThreadingMixIn, http.server.HTTPServer):
+    daemon_threads = True
+    allow_reuse_address = True
+
+
+class LiveServer:
+    """Convenience wrapper combining the HTTP server and the watcher."""
+
+    def __init__(self, directory=".", port=8000):
+        self.directory = os.path.abspath(directory)
+        self.port = int(port)
+        self.hub = ReloadHub()
+        self.watcher = None
+        self.httpd = None
+
+    def start(self):
+        handler = functools.partial(NoCacheHandler, directory=self.directory)
+        self.httpd = ThreadingHTTPServer(("", self.port), handler)
+        self.httpd.hub = self.hub
+        if is_watchable():
+            self.watcher = Watcher(self.directory, self.hub.broadcast).start()
+        return self
+
+    def serve_forever(self):
+        if self.httpd is None:
+            self.start()
+        try:
+            self.httpd.serve_forever()
+        except KeyboardInterrupt:
+            pass
+        finally:
+            self.close()
+
+    def close(self):
+        if self.watcher is not None:
+            self.watcher.close()
+        if self.httpd is not None:
+            self.httpd.server_close()
+
+
+def create_server(directory=".", port=8000):
+    """Create (but do not start) a LiveServer."""
+    return LiveServer(directory=directory, port=port)

servelive-0.1.0/src/servelive/watcher.py

@@ -0,0 +1,186 @@
+"""inotify-backed change detection.
+
+Watches a directory tree with the Linux inotify API through ctypes (stdlib
+only). Calls a callback once per debounced change burst so consumers get a
+single notification for what would otherwise be a burst of raw inotify events.
+"""
+
+import ctypes
+import ctypes.util
+import errno
+import os
+import select
+import struct
+import threading
+import time
+
+try:
+    _libc_path = ctypes.util.find_library("c") or (
+        "/lib/libc.so.6" if os.path.exists("/lib/libc.so.6") else "libc.so.6"
+    )
+    libc = ctypes.CDLL(_libc_path, use_errno=True)
+    INOTIFY_OK = True
+except Exception:  # pragma: no cover - platform without libc
+    libc = None
+    INOTIFY_OK = False
+
+IN_ATTRIB = 0x00000002
+IN_CREATE = 0x00000100
+IN_DELETE = 0x00000200
+IN_MODIFY = 0x00000002
+IN_MOVED_FROM = 0x00000040
+IN_MOVED_TO = 0x00000080
+IN_CLOSE_WRITE = 0x00000008
+
+_WATCH_MASK = (
+    IN_ATTRIB
+    | IN_CREATE
+    | IN_DELETE
+    | IN_MODIFY
+    | IN_MOVED_FROM
+    | IN_MOVED_TO
+    | IN_CLOSE_WRITE
+)
+
+_SIZE_OF_INOTIFY_EVENT = 16
+_NAME_MAX = 4096
+
+
+def _setup_libc():
+    if not INOTIFY_OK:
+        return
+    libc.inotify_init.restype = ctypes.c_int
+    libc.inotify_add_watch.restype = ctypes.c_int
+    libc.inotify_add_watch.argtypes = [
+        ctypes.c_int, ctypes.c_char_p, ctypes.c_uint32,
+    ]
+    libc.inotify_rm_watch.argtypes = [ctypes.c_int, ctypes.c_int]
+    libc.read.argtypes = [ctypes.c_int, ctypes.c_void_p, ctypes.c_size_t]
+    libc.read.restype = ctypes.c_ssize_t
+    libc.close.argtypes = [ctypes.c_int]
+
+
+_setup_libc()
+
+
+def is_watchable():
+    """Return True if inotify is available on this system."""
+    return INOTIFY_OK
+
+
+class Watcher:
+    """Watch a directory tree and call ``on_change`` per debounced change."""
+
+    def __init__(self, root, on_change, debounce_ms=80, poll_ms=250):
+        self.root = root
+        self.on_change = on_change
+        self.debounce_ms = debounce_ms / 1000.0
+        self.poll_ms = poll_ms
+        self._fd = None
+        self._wd_to_path = {}
+
+    def start(self):
+        """Start watching. Returns self, or None if inotify is unavailable."""
+        if not INOTIFY_OK:
+            return None
+        fd = libc.inotify_init()
+        if fd < 0:
+            return None
+        self._fd = fd
+
+        mask = _WATCH_MASK
+        poll = select.poll()
+        poll.register(fd, select.POLLIN)
+        buf = ctypes.create_string_buffer(_NAME_MAX * 4)
+
+        def add_watch(path):
+            wd = libc.inotify_add_watch(fd, os.fsencode(path), mask)
+            if wd >= 0:
+                self._wd_to_path[wd] = path
+            return wd
+
+        def add_tree(base):
+            for dirpath, dirnames, _ in os.walk(base):
+                for d in list(dirnames):
+                    try:
+                        add_watch(os.path.join(dirpath, d))
+                    except OSError:
+                        pass
+
+        root_wd = add_watch(self.root)
+        if root_wd < 0:
+            libc.close(fd)
+            self._fd = None
+            return None
+        add_tree(self.root)
+
+        pending = {"flag": False}
+        lock = threading.Lock()
+        debounce = threading.Event()
+
+        def mark_changed():
+            with lock:
+                pending["flag"] = True
+            debounce.set()
+
+        def broadcaster():
+            while True:
+                debounce.wait()
+                debounce.clear()
+                time.sleep(self.debounce_ms)
+                with lock:
+                    if not pending["flag"]:
+                        continue
+                    pending["flag"] = False
+                self.on_change()
+
+        threading.Thread(target=broadcaster, daemon=True).start()
+
+        def loop():
+            while True:
+                if not poll.poll(self.poll_ms):
+                    continue
+                while True:
+                    n = libc.read(fd, buf, len(buf))
+                    if n < 0:
+                        err = ctypes.get_errno()
+                        if err in (errno.EAGAIN, errno.EINTR):
+                            break
+                        continue
+                    if n == 0:
+                        break
+                    off = 0
+                    while off < n:
+                        wd, maskv, _cookie, name_len = struct.unpack_from(
+                            "iIII", buf, off
+                        )
+                        off += _SIZE_OF_INOTIFY_EVENT
+                        name = (
+                            buf.raw[off:off + name_len]
+                            .split(b"\x00", 1)[0]
+                            .decode("utf-8", "replace")
+                            if name_len
+                            else ""
+                        )
+                        off += name_len
+                        dirname = self._wd_to_path.get(wd, self.root)
+                        if (maskv & (IN_CREATE | IN_MOVED_TO)) and name:
+                            newpath = os.path.join(dirname, name)
+                            if os.path.isdir(newpath):
+                                try:
+                                    add_watch(newpath)
+                                except OSError:
+                                    pass
+                        mark_changed()
+
+        threading.Thread(target=loop, daemon=True).start()
+        return self
+
+    def close(self):
+        """Stop watching and release the inotify fd."""
+        if self._fd is not None:
+            try:
+                libc.close(self._fd)
+            except Exception:
+                pass
+            self._fd = None

servelive-0.1.0/src/servelive.egg-info/PKG-INFO

@@ -0,0 +1,75 @@
+Metadata-Version: 2.4
+Name: servelive
+Version: 0.1.0
+Summary: Static file server with no-cache headers and inotify-driven live reload over SSE
+Author-email: Reymart Centeno <reymartcenteno03@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/groovyrey/servelive
+Classifier: Environment :: Web Environment
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Internet :: WWW/HTTP :: HTTP Servers
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Dynamic: license-file
+
+# servelive
+
+A static file server with no-cache headers and live reload, powered by Linux
+inotify and Server-Sent Events. A drop-in replacement for `python3 -m http.server`
+that refreshes the browser the moment a served file changes. No polling anywhere,
+and no third-party dependencies (pure Python standard library + the system libc).
+
+## Features
+
+- No-cache headers on every response so dev browsers always fetch fresh files
+- Live reload via **inotify** (real file-change detection) + **SSE** push
+- Serves over the network by default (`0.0.0.0`) and prints your LAN address
+- Degrades gracefully on systems without inotify (survives, just no reload)
+
+## Install
+
+```bash
+pip install servelive
+```
+
+## Usage
+
+```bash
+servelive                 # serve ./ on port 8000
+servelive 8500            # serve ./ on port 8500
+servelive 8500 ./site     # serve ./site on port 8500
+servelive --bind 127.0.0.1 9000   # localhost only
+```
+
+Startup output mirrors a JS dev server:
+
+```
+  local:   http://localhost:8000/
+  network: http://192.168.100.167:8000/
+  serving /home/you/site (live reload via inotify)
+```
+
+Open the `local:` or `network:` URL in a browser, edit any file under the served
+directory, and the page reloads itself.
+
+## How it works
+
+1. A background thread watches the served tree with the Linux `inotify` API
+   (called through `ctypes`, stdlib only).
+2. On a change, an 80 ms debounce coalesces the raw event burst into a single
+   notification.
+3. The server broadcasts a reload over an SSE stream to every connected page.
+
+The reload script is injected into served HTML, so any page you open through
+`servelive` gets live reload automatically.
+
+## License
+
+MIT

servelive-0.1.0/src/servelive.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+LICENSE
+README.md
+pyproject.toml
+src/servelive/__init__.py
+src/servelive/__main__.py
+src/servelive/_version.py
+src/servelive/cli.py
+src/servelive/server.py
+src/servelive/watcher.py
+src/servelive.egg-info/PKG-INFO
+src/servelive.egg-info/SOURCES.txt
+src/servelive.egg-info/dependency_links.txt
+src/servelive.egg-info/entry_points.txt
+src/servelive.egg-info/requires.txt
+src/servelive.egg-info/top_level.txt

servelive-0.1.0/src/servelive.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

servelive-0.1.0/src/servelive.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+servelive = servelive.cli:main

servelive-0.1.0/src/servelive.egg-info/requires.txt

@@ -0,0 +1,5 @@
+
+[dev]
+pytest
+build
+twine

servelive-0.1.0/src/servelive.egg-info/top_level.txt

@@ -0,0 +1 @@
+servelive