#!/usr/bin/env python3 """Local Gurbani waveform section editor server. Parent-folder convention: parent/ Project One/ recording.mp3 aligned_transcript.json Project Two/ another.mp3 transcript_sections.json Project folders are discovered recursively. A project folder must contain an MP3 and a transcript JSON with a ``sections`` array. The JSON filename can be ``aligned_transcript.json``, ``aligned_transcript copy.json``, or ``transcript_sections.json``. When present, ``audio_file`` selects the MP3. Hidden files and hidden directories are ignored. Run: python server.py python server.py --parent-folder /path/to/parent --port 8000 python server.py --parent-folder /path/to/parent --longer 20 """ from __future__ import annotations import argparse import array import json import mimetypes import os import shutil import subprocess import sys import tempfile import math from datetime import datetime from http import HTTPStatus from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer from pathlib import Path from urllib.parse import parse_qs, quote, unquote, urlparse HOST = "127.0.0.1" DEFAULT_PORT = 8000 AUDIO_EXTENSIONS = {".mp3", ".wav", ".m4a", ".flac", ".ogg"} TRANSCRIPT_JSON_NAME = "aligned_transcript.json" ROOT_PROJECT_KEY = "__root__" BASE_DIR = Path(__file__).resolve().parent INDEX_FILE = BASE_DIR / "index.html" def clean_payload(payload: object) -> dict: """Return the input schema without adding, deleting, or normalising fields.""" if isinstance(payload, dict): return payload elif isinstance(payload, list): return {"sections": payload} return {"sections": []} def transcript_payload(json_path: Path) -> dict | None: """Read a transcript JSON candidate, rejecting unrelated JSON files.""" try: payload = json.loads(json_path.read_text(encoding="utf-8")) except (OSError, json.JSONDecodeError): return None sections = payload.get("sections") if isinstance(payload, dict) else None if not isinstance(sections, list): return None if not any( isinstance(section, dict) and "start_time" in section and "end_time" in section and "transcript" in section for section in sections ): return None return payload def transcript_json_priority(path: Path) -> tuple[int, str]: name = path.name.casefold() preferred = { "aligned_transcript.json": 0, "aligned_transcript copy.json": 1, "transcript_sections.json": 2, } if name in preferred: rank = preferred[name] elif name.startswith("aligned_transcript"): rank = 3 elif name.startswith("transcript_sections"): rank = 4 else: rank = 5 return rank, name def merge_editable_fields( original: object, submitted: object, preserve_section_ids: list[str] | None = None, renumber_section_ids: bool = False, ) -> dict: """Apply edits while optionally retaining sections hidden by a duration filter.""" if isinstance(original, dict): result = dict(original) original_sections = original.get("sections", []) else: result = {} original_sections = original if isinstance(original, list) else [] submitted_sections = submitted.get("sections", []) if isinstance(submitted, dict) else [] if not isinstance(original_sections, list): original_sections = [] if not isinstance(submitted_sections, list): submitted_sections = [] originals_by_id = { str(section.get("section_id")): section for section in original_sections if isinstance(section, dict) and section.get("section_id") is not None } replacements: dict[str, dict] = {} new_sections: list[dict] = [] submitted_order: list[dict] = [] editable = ("section_id", "transcript", "start_time", "end_time") for edited in submitted_sections: if not isinstance(edited, dict): continue # The editor renumbers serial IDs after a split/join. Its transient # source ID identifies the original section whose other fields must be # retained. Older clients without this marker still match by section ID. source_id = ( edited.get("__source_section_id") if "__source_section_id" in edited else edited.get("section_id") ) original_section = originals_by_id.get(str(source_id)) if source_id is not None else None if original_section is None: # Split/insert creates a new section. Keep only the fields required # by this transcript/timing schema; never copy unrelated metadata. new_section = {key: edited[key] for key in ("section_id", *editable) if key in edited} new_sections.append(new_section) submitted_order.append(new_section) continue new_section = dict(original_section) for key in editable: if key in edited: new_section[key] = edited[key] replacements[str(source_id)] = new_section submitted_order.append(new_section) if preserve_section_ids is None: # Normal mode submits every section; omission means intentional deletion. merged = submitted_order else: # Longer-only mode submits just the visible sections. Retain source # sections that were hidden by the threshold and omit deleted visible # sections. Then put new split sections back in audio-time order. preserve_ids = {str(section_id) for section_id in preserve_section_ids} merged = [] for section in original_sections: if not isinstance(section, dict): continue source_id = section.get("section_id") key = str(source_id) if source_id is not None else None if key in replacements: merged.append(replacements[key]) elif key in preserve_ids: merged.append(section) merged.extend(new_sections) def section_start(section: dict) -> tuple[float, float]: try: start = float(section.get("start_time", 0)) except (TypeError, ValueError): start = 0.0 try: end = float(section.get("end_time", start)) except (TypeError, ValueError): end = start return start, end merged.sort(key=section_start) if renumber_section_ids: for index, section in enumerate(merged, 1): section["section_id"] = f"section-{index}" result["sections"] = merged return result class EditorServer(ThreadingHTTPServer): daemon_threads = True def __init__( self, address, handler, parent_folder: Path, sections: bool, longer_seconds: float | None = None, ): super().__init__(address, handler) self.parent_folder = parent_folder.resolve() self.sections = sections self.longer_seconds = longer_seconds @staticmethod def _has_hidden_part(relative_path: Path) -> bool: return any(part.startswith(".") for part in relative_path.parts) def project_folders(self) -> list[Path]: """Return valid project folders found recursively below the parent.""" projects: list[Path] = [] try: candidates = list(self.parent_folder.rglob("*.json")) # The configured root can itself be one project. candidates.extend(self.parent_folder.glob("*.json")) for json_path in candidates: if not json_path.is_file() or json_path.name.startswith("."): continue if transcript_payload(json_path) is None: continue folder = json_path.parent.resolve() try: relative = folder.relative_to(self.parent_folder) except ValueError: continue if self._has_hidden_part(relative): continue if self.resolve_project(self.project_key(folder)) is not None: projects.append(folder) except OSError: return [] return sorted( set(projects), key=lambda path: path.relative_to(self.parent_folder).as_posix().casefold(), ) def project_key(self, folder: Path) -> str: relative = folder.resolve().relative_to(self.parent_folder) return ROOT_PROJECT_KEY if not relative.parts else relative.as_posix() def resolve_project(self, name: str) -> tuple[Path, Path, Path] | None: """Resolve a recursive project path safely below the parent folder.""" raw_name = str(name).strip().replace("\\", "/") if raw_name == ROOT_PROJECT_KEY: folder = self.parent_folder else: relative = Path(raw_name) if ( not raw_name or relative.is_absolute() or any(part in {"", ".", ".."} or part.startswith(".") for part in relative.parts) ): return None folder = (self.parent_folder / relative).resolve() try: checked_relative = folder.relative_to(self.parent_folder) except ValueError: return None if self._has_hidden_part(checked_relative): return None if not folder.is_dir(): return None audio_candidates = sorted( ( path for path in folder.iterdir() if path.is_file() and path.suffix.casefold() == ".mp3" and not path.name.startswith(".") ), key=lambda path: path.name.casefold(), ) if not audio_candidates: return None json_options = [] for candidate in folder.glob("*.json"): if candidate.name.startswith("."): continue payload = transcript_payload(candidate) if payload is None: continue audio_name = Path(str(payload.get("audio_file") or "")).name if isinstance(payload, dict) else "" matching_audio = next( (audio for audio in audio_candidates if audio.name.casefold() == audio_name.casefold()), None, ) json_options.append((0 if matching_audio else 1, *transcript_json_priority(candidate), candidate, matching_audio)) if not json_options: return None json_options.sort(key=lambda option: option[:3]) _, _, _, json_path, audio = json_options[0] if audio is None: audio = audio_candidates[0] return folder, audio.resolve(), json_path.resolve() def resolve_audio(self, project_name: str) -> Path | None: project = self.resolve_project(project_name) return project[1] if project else None def resolve_json_for_audio( self, project_name: str, existing_only: bool = False, ) -> Path | None: project = self.resolve_project(project_name) return project[2] if project else None # Auto-align tuning. These values are intentionally grouped here. AUTO_ALIGN_FRAME_MS = 10 AUTO_ALIGN_SMOOTH_MS = 80 AUTO_ALIGN_CONTEXT_SECONDS = 1.5 AUTO_ALIGN_MIN_QUIET_SECONDS = 0.28 AUTO_ALIGN_ALLOWED_SPIKE_SECONDS = 0.03 AUTO_ALIGN_END_PADDING_SECONDS = 0.00 AUTO_ALIGN_ABSOLUTE_FLOOR = 0.00075 AUTO_ALIGN_NOISE_MULTIPLIER = 2.6 AUTO_ALIGN_CONTEXT_RATIO = 0.040 AUTO_ALIGN_MAX_THRESHOLD = 0.0060 def _percentile(values: list[float], fraction: float) -> float: if not values: return 0.0 ordered = sorted(values) index = max(0, min(len(ordered) - 1, round((len(ordered) - 1) * fraction))) return ordered[index] def analyse_section_tail( audio_path: Path, section_start: float, current_end: float, next_start: float | None = None, ) -> dict: """Extend forward to the minimum point of the first sustained low-energy valley. The threshold is based mainly on audio immediately before ``current_end``. Later bursts before the next section cannot influence that threshold. Once the first genuine quiet valley is confirmed, all later energy is ignored. The returned boundary never moves backwards and never passes ``next_start``. """ sample_rate = 16000 frame_ms = AUTO_ALIGN_FRAME_MS frame_seconds = frame_ms / 1000.0 frame_samples = sample_rate * frame_ms // 1000 scan_start = max(0.0, current_end - AUTO_ALIGN_CONTEXT_SECONDS) search_offset = current_end - scan_start if next_start is not None: hard_limit = max(current_end, next_start) else: hard_limit = current_end + 15.0 scan_seconds = max(frame_seconds, min(60.0, hard_limit - scan_start)) command = [ "ffmpeg", "-v", "error", "-ss", f"{scan_start:.3f}", "-t", f"{scan_seconds:.3f}", "-i", str(audio_path), "-ac", "1", "-ar", str(sample_rate), "-f", "f32le", "pipe:1", ] try: result = subprocess.run( command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, check=True, ) except FileNotFoundError as exc: raise RuntimeError( "ffmpeg is required for Align Unvalidated but was not found" ) from exc except subprocess.CalledProcessError as exc: message = exc.stderr.decode("utf-8", errors="replace").strip() raise RuntimeError( f"ffmpeg could not decode the audio: {message or exc}" ) from exc samples = array.array("f") samples.frombytes(result.stdout) if not samples: return {"aligned_end": round(current_end, 3), "mode": "no_audio"} rms_values: list[float] = [] for offset in range(0, len(samples) - frame_samples + 1, frame_samples): frame = samples[offset:offset + frame_samples] energy = sum(float(value) * float(value) for value in frame) / len(frame) rms_values.append(math.sqrt(energy)) if not rms_values: return {"aligned_end": round(current_end, 3), "mode": "no_frames"} smooth_frames = max(1, round(AUTO_ALIGN_SMOOTH_MS / frame_ms)) half_window = smooth_frames // 2 smoothed: list[float] = [] for i in range(len(rms_values)): lo = max(0, i - half_window) hi = min(len(rms_values), i + half_window + 1) smoothed.append(sum(rms_values[lo:hi]) / (hi - lo)) search_index = max( 0, min(len(smoothed) - 1, round(search_offset / frame_seconds)), ) # The context ends at the existing boundary and therefore represents the # current section only. A later high-energy burst cannot raise or lower the # threshold used to identify the first valley. context_start = max(0, search_index - round(1.2 / frame_seconds)) context_values = smoothed[context_start:search_index + 1] context_level = _percentile(context_values, 0.75) # Estimate the local floor from the forward search, but use only its lowest # portion. This adapts to recording hiss while remaining independent of a # later spoken or sung burst. forward_values = smoothed[search_index:] noise_floor = _percentile(forward_values, 0.10) threshold = max( AUTO_ALIGN_ABSOLUTE_FLOOR, noise_floor * AUTO_ALIGN_NOISE_MULTIPLIER, context_level * AUTO_ALIGN_CONTEXT_RATIO, ) threshold = min(threshold, AUTO_ALIGN_MAX_THRESHOLD) quiet_frames_required = max( 1, round(AUTO_ALIGN_MIN_QUIET_SECONDS / frame_seconds), ) allowed_spike_frames = max( 0, round(AUTO_ALIGN_ALLOWED_SPIKE_SECONDS / frame_seconds), ) quiet_start: int | None = None quiet_count = 0 spike_count = 0 for i in range(search_index, len(smoothed)): value = smoothed[i] if value <= threshold: if quiet_start is None: quiet_start = i quiet_count += 1 spike_count = 0 elif quiet_start is not None and spike_count < allowed_spike_frames: # Permit a very short click or isolated noisy frame inside an # otherwise continuous valley. spike_count += 1 else: quiet_start = None quiet_count = 0 spike_count = 0 if quiet_start is not None and quiet_count >= quiet_frames_required: # The valley is now confirmed. Place the boundary at the lowest # energy frame inside this first confirmed valley, not at the first # frame that crossed the threshold. This better matches the visual # low point in the waveform and still prevents a later burst from # being included. confirmed_end = i + 1 valley_values = smoothed[quiet_start:confirmed_end] minimum_offset = min( range(len(valley_values)), key=valley_values.__getitem__, ) minimum_index = quiet_start + minimum_offset minimum_time = scan_start + minimum_index * frame_seconds valley_start_time = scan_start + quiet_start * frame_seconds aligned_end = max( current_end, minimum_time + AUTO_ALIGN_END_PADDING_SECONDS, ) if next_start is not None: aligned_end = min(aligned_end, next_start) return { "aligned_end": round(aligned_end, 3), "mode": "first_valley_minimum", "threshold": threshold, "noise_floor": noise_floor, "context_level": context_level, "valley_start": round(valley_start_time, 3), "valley_minimum": round(minimum_time, 3), "valley_minimum_energy": valley_values[minimum_offset], } if next_start is not None: aligned_end = next_start mode = "next_section_start" else: aligned_end = scan_start + len(smoothed) * frame_seconds mode = "scan_limit" return { "aligned_end": round(max(current_end, aligned_end), 3), "mode": mode, "threshold": threshold, "noise_floor": noise_floor, "context_level": context_level, } def project_validation_summary(json_path: Path) -> dict: """Return validation progress without modifying the project JSON.""" try: payload = json.loads(json_path.read_text(encoding="utf-8")) except (OSError, json.JSONDecodeError): return { "all_validated": False, "validated_count": 0, "section_count": 0, } if isinstance(payload, dict): sections = payload.get("sections", []) elif isinstance(payload, list): sections = payload else: sections = [] if not isinstance(sections, list): sections = [] valid_sections = [section for section in sections if isinstance(section, dict)] validated_count = sum( 1 for section in valid_sections if section.get("validated") is True ) section_count = len(valid_sections) return { # An empty project is not treated as completed. "all_validated": section_count > 0 and validated_count == section_count, "validated_count": validated_count, "section_count": section_count, } def sections_over_duration(json_path: Path, seconds: float) -> list[dict]: """Read sections whose audio span is strictly longer than the threshold.""" try: payload = json.loads(json_path.read_text(encoding="utf-8")) except (OSError, json.JSONDecodeError): return [] sections = payload.get("sections", []) if isinstance(payload, dict) else payload if not isinstance(sections, list): return [] result = [] for section in sections: if not isinstance(section, dict): continue try: duration = float(section.get("end_time", 0)) - float(section.get("start_time", 0)) except (TypeError, ValueError): continue if duration > seconds: result.append(section) return result class Handler(BaseHTTPRequestHandler): server_version = "GurbaniSectionEditor/recursive-projects-v6-valley-minimum" @property def app(self) -> EditorServer: return self.server # type: ignore[return-value] def log_message(self, fmt: str, *args): sys.stdout.write("[%s] %s\n" % (self.log_date_time_string(), fmt % args)) def send_json(self, data: object, status: int = 200): body = json.dumps(data, ensure_ascii=False).encode("utf-8") self.send_response(status) self.send_header("Content-Type", "application/json; charset=utf-8") self.send_header("Content-Length", str(len(body))) self.send_header("Cache-Control", "no-store") self.end_headers() self.wfile.write(body) def send_error_json(self, status: int, message: str): self.send_json({"error": message}, status) def do_GET(self): parsed = urlparse(self.path) path = parsed.path query = parse_qs(parsed.query) if path == "/": try: body = INDEX_FILE.read_bytes() except OSError as exc: return self.send_error_json(500, f"Cannot read index.html: {exc}") self.send_response(200) self.send_header("Content-Type", "text/html; charset=utf-8") self.send_header("Content-Length", str(len(body))) self.send_header("Cache-Control", "no-store") self.end_headers() self.wfile.write(body) return if path == "/api/server-info": return self.send_json({ "version": "mp3-aligned-transcript-v3", "parent_folder": str(self.app.parent_folder), "longer_seconds": self.app.longer_seconds, "project_rule": "recursive non-hidden folders containing a transcript JSON with sections and an MP3", }) if path == "/api/files": files = [] for folder in self.app.project_folders(): project_key = self.app.project_key(folder) project = self.app.resolve_project(project_key) if project is None: continue _, audio, json_path = project validation = project_validation_summary(json_path) if self.app.longer_seconds is not None: matching_sections = sections_over_duration( json_path, self.app.longer_seconds ) if not matching_sections: continue validated_count = sum( 1 for section in matching_sections if section.get("validated") is True ) validation = { "all_validated": validated_count == len(matching_sections), "validated_count": validated_count, "section_count": len(matching_sections), } files.append({ "name": project_key, "display_name": ( self.app.parent_folder.name if project_key == ROOT_PROJECT_KEY else project_key.replace("/", " / ") ), "audio_name": audio.name, "audio_file_name": audio.name, "json_name": json_path.name, "has_json": True, "all_validated": validation["all_validated"], "validated_count": validation["validated_count"], "section_count": validation["section_count"], "audio_size": audio.stat().st_size, "modified": datetime.fromtimestamp( max(audio.stat().st_mtime, json_path.stat().st_mtime) ).isoformat(timespec="seconds"), }) return self.send_json({ "folder": str(self.app.parent_folder), "longer_seconds": self.app.longer_seconds, "files": files, }) if path == "/api/project": name = query.get("name", [""])[0] project = self.app.resolve_project(name) if project is None: return self.send_error_json( 404, "Project folder not found or it does not contain a transcript JSON with sections and an MP3", ) folder, audio, json_path = project try: payload = json.loads(json_path.read_text(encoding="utf-8")) except Exception as exc: return self.send_error_json(500, f"Cannot read JSON: {exc}") return self.send_json({ "audio_name": name, "audio_file_name": audio.name, "project_name": name, "json_name": json_path.name, "audio_url": f"/api/audio?name={quote(name)}", "data": clean_payload(payload), }) if path == "/api/audio": name = query.get("name", [""])[0] audio = self.app.resolve_audio(name) if not audio: return self.send_error_json(404, "Project audio not found") return self.serve_file_with_range(audio) self.send_error_json(404, "Not found") def serve_file_with_range(self, path: Path): size = path.stat().st_size mime = mimetypes.guess_type(path.name)[0] or "application/octet-stream" start, end = 0, size - 1 status = HTTPStatus.OK range_header = self.headers.get("Range") if range_header and range_header.startswith("bytes="): try: spec = range_header.removeprefix("bytes=").split(",", 1)[0] first, last = spec.split("-", 1) if first: start = int(first) if last: end = int(last) else: end = size - 1 start = max(0, min(start, size - 1)) end = max(start, min(end, size - 1)) status = HTTPStatus.PARTIAL_CONTENT except Exception: return self.send_error_json(416, "Invalid Range header") length = end - start + 1 self.send_response(status) self.send_header("Content-Type", mime) self.send_header("Accept-Ranges", "bytes") self.send_header("Content-Length", str(length)) if status == HTTPStatus.PARTIAL_CONTENT: self.send_header("Content-Range", f"bytes {start}-{end}/{size}") self.send_header("Cache-Control", "no-cache") self.end_headers() with path.open("rb") as handle: handle.seek(start) remaining = length while remaining > 0: chunk = handle.read(min(1024 * 1024, remaining)) if not chunk: break self.wfile.write(chunk) remaining -= len(chunk) def do_POST(self): parsed = urlparse(self.path) if parsed.path not in {"/api/save", "/api/auto-align"}: return self.send_error_json(404, "Not found") try: length = int(self.headers.get("Content-Length", "0")) except ValueError: return self.send_error_json(400, "Invalid Content-Length") if length <= 0 or length > 50 * 1024 * 1024: return self.send_error_json(400, "Invalid request size") try: request = json.loads(self.rfile.read(length).decode("utf-8")) except Exception as exc: return self.send_error_json(400, f"Invalid JSON request: {exc}") if not isinstance(request, dict): return self.send_error_json(400, "Request must be an object") if parsed.path == "/api/auto-align": audio_name = str(request.get("audio_name") or "") audio = self.app.resolve_audio(audio_name) if not audio: return self.send_error_json(404, "Project audio not found") try: section_start = float(request.get("section_start", 0)) current_end = float(request.get("current_end", section_start)) next_value = request.get("next_start") next_start = None if next_value is None else float(next_value) except (TypeError, ValueError): return self.send_error_json(400, "Invalid section timing") if current_end <= section_start: return self.send_error_json(400, "Section end must be after its start") if next_start is not None and next_start <= section_start + 0.02: return self.send_error_json(400, "Next section must start after this section") try: result = analyse_section_tail( audio, section_start, current_end, next_start ) except RuntimeError as exc: return self.send_error_json(500, str(exc)) if result.get("mode") == "next_section_start": result["message"] = "Audible energy reaches the next section" elif result["aligned_end"] != round(current_end, 3): result["message"] = "Aligned to the end of the audible waveform" else: result["message"] = "No reliable waveform end was found" return self.send_json(result) audio_name = str(request.get("audio_name") or "") json_path = self.app.resolve_json_for_audio(audio_name) if not json_path: return self.send_error_json(400, "Invalid audio name") try: original_payload = json.loads(json_path.read_text(encoding="utf-8")) except Exception as exc: return self.send_error_json(500, f"Cannot read source JSON: {exc}") preserve_ids_value = request.get("preserve_section_ids") preserve_ids = ( [str(value) for value in preserve_ids_value] if isinstance(preserve_ids_value, list) else None ) payload = merge_editable_fields( original_payload, request.get("data"), preserve_section_ids=preserve_ids, renumber_section_ids=request.get("renumber_section_ids") is True, ) try: json_path.parent.mkdir(parents=True, exist_ok=True) backup = None if json_path.exists(): backup = json_path.with_suffix(json_path.suffix + ".bak") shutil.copy2(json_path, backup) fd, temp_name = tempfile.mkstemp(prefix=json_path.name + ".", suffix=".tmp", dir=json_path.parent) try: with os.fdopen(fd, "w", encoding="utf-8", newline="\n") as handle: json.dump(payload, handle, ensure_ascii=False, indent=2) handle.write("\n") handle.flush() os.fsync(handle.fileno()) os.replace(temp_name, json_path) finally: if os.path.exists(temp_name): os.unlink(temp_name) except Exception as exc: return self.send_error_json(500, f"Save failed: {exc}") return self.send_json({ "saved": True, "json_name": json_path.name, "sections": len(payload["sections"]), "backup_name": backup.name if backup else None, "data": payload, }) def main() -> int: parser = argparse.ArgumentParser( description=( "Serve the editor from a parent folder and recursively discover " "folders containing transcript JSON files with sections and an MP3" ) ) parser.add_argument( "--parent-folder", "--kirtan-folder", dest="parent_folder", default="kirtan", help=( "Parent folder searched recursively. Each project folder must contain " "a transcript JSON file with sections and an MP3. " "--kirtan-folder remains as a backwards-compatible alias." ), ) parser.add_argument("--host", default=HOST) parser.add_argument("--port", type=int, default=DEFAULT_PORT) parser.add_argument("--sections", default=False) parser.add_argument( "--longer", type=float, default=None, metavar="SECONDS", help="Show only projects and sections with a duration longer than SECONDS", ) args = parser.parse_args() if args.longer is not None and args.longer <= 0: parser.error("--longer must be greater than 0 seconds") folder = Path(args.parent_folder).expanduser().resolve() folder.mkdir(parents=True, exist_ok=True) server = EditorServer( (args.host, args.port), Handler, folder, args.sections, longer_seconds=args.longer, ) print("Server version: mp3-aligned-transcript-v3") print(f"Parent folder: {folder}") print("Projects: recursive non-hidden folders containing a transcript JSON with sections and an MP3") if args.longer is not None: print(f"Longer-only filter: sections longer than {args.longer:g} seconds") print(f"Open: http://{args.host}:{args.port}") try: server.serve_forever() except KeyboardInterrupt: print("\nStopping server") finally: server.server_close() return 0 if __name__ == "__main__": raise SystemExit(main())