flexsds 0.2.0__py3-none-any.whl

flexsds/cli/wizard.py

@@ -0,0 +1,360 @@
+"""Interactive serving wizard for FlexSDS with arrow-key navigation."""
+from __future__ import annotations
+
+import json
+import os
+import sys
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+try:
+    import termios
+    import tty
+    HAS_TERMIOS = True
+except ImportError:
+    HAS_TERMIOS = False
+
+try:
+    from flexsds.cli.output import print_output as print
+    from flexsds.core.hardware import detect_hardware, HardwareInfo
+    from flexsds.core.compatibility import (
+        evaluate_serving_preflight,
+        ServingBlockedError,
+    )
+    from flexsds.core.cost_model import load_profile_for_hardware
+    from flexsds.server.local_runner import LocalServingRunner, finish_launch
+    from flexsds.server.colab_runner import ColabServingRunner
+    from flexsds.server.modal_runner import ModalServingRunner
+except ModuleNotFoundError:
+    from src.flexsds.cli.output import print_output as print
+    from src.flexsds.core.hardware import detect_hardware, HardwareInfo
+    from src.flexsds.core.compatibility import (
+        evaluate_serving_preflight,
+        ServingBlockedError,
+    )
+    from src.flexsds.core.cost_model import load_profile_for_hardware
+    from src.flexsds.server.local_runner import LocalServingRunner, finish_launch
+    from src.flexsds.server.colab_runner import ColabServingRunner
+    from src.flexsds.server.modal_runner import ModalServingRunner
+
+
+PLATFORM_CHOICES = [
+    "Modal.com (Serverless GPU đám mây)",
+    "Google Colab (GPU miễn phí T4/L4)",
+    "Tự dùng GPU nội bộ (Local vLLM)",
+]
+
+
+def strip_ansi(s: str) -> str:
+    """Removes ANSI escape codes to calculate visible string length."""
+    import re
+    return re.sub(r"\033\[[0-9;]*m", "", s)
+
+
+def render_box(title: str, items: list[tuple[str, str, str]], min_width: int = 56) -> str:
+    """Renders a self-adjusting border box with perfectly aligned borders.
+
+    items: list of (label, value, value_ansi_color)
+    """
+    max_label_w = max(len(strip_ansi(label)) for label, _, _ in items) if items else 12
+    label_w = max(max_label_w, 14)
+
+    max_content_w = len(title) + 6
+    for label, val, _ in items:
+        line_w = label_w + len(strip_ansi(val)) + 5
+        if line_w > max_content_w:
+            max_content_w = line_w
+
+    inner_w = max(max_content_w, min_width)
+
+    title_strip = strip_ansi(title)
+    top_left = "─── "
+    remaining = inner_w - len(top_left) - len(title_strip) - 1
+    top_right = "─" * max(2, remaining)
+    actual_inner = len(top_left) + len(title_strip) + 1 + len(top_right)
+
+    top = f"\033[90m┌{top_left}\033[1;37m{title_strip}\033[0m\033[90m {top_right}┐\033[0m"
+    bottom = "\033[90m└" + "─" * actual_inner + "┘\033[0m"
+
+    lines = [top]
+    for label, val, color in items:
+        clean_label = strip_ansi(label)
+        clean_val = strip_ansi(val)
+        prefix = f" {clean_label:<{label_w}} : "
+        used = len(prefix) + len(clean_val)
+        pad = " " * max(1, actual_inner - used)
+        row = f"\033[90m│\033[0m{prefix}{color}{clean_val}\033[0m{pad}\033[90m│\033[0m"
+        lines.append(row)
+
+    lines.append(bottom)
+    return "\n".join(lines)
+
+
+def prompt_choice(question: str, choices: list[str], default_idx: int = 0) -> str:
+    """Prompt user to select an option using arrow keys and Enter."""
+    if not sys.stdin.isatty() or not HAS_TERMIOS:
+        print(f"\033[32m✔\033[0m \033[1m{question}\033[0m \033[36m{choices[default_idx]}\033[0m")
+        return choices[default_idx]
+
+    current = default_idx
+    n = len(choices)
+
+    print(f"\n\033[1;37m? {question}\033[0m\n", end="")
+    print("\033[?25l", end="")  # Hide cursor
+    sys.stdout.flush()
+
+    def render(first: bool = False) -> None:
+        if not first:
+            print(f"\033[{n}A", end="")
+        for i, choice in enumerate(choices):
+            print("\r\033[K", end="")
+            if i == current:
+                print(f"  \033[1;37m> {choice}\033[0m\n", end="")
+            else:
+                print(f"    \033[90m{choice}\033[0m\n", end="")
+        sys.stdout.flush()
+
+    render(first=True)
+
+    fd = sys.stdin.fileno()
+    old_settings = termios.tcgetattr(fd)
+    try:
+        tty.setcbreak(fd)
+        while True:
+            ch = sys.stdin.read(1)
+            if ch == "\x1b":
+                ch2 = sys.stdin.read(1)
+                if ch2 == "[":
+                    ch3 = sys.stdin.read(1)
+                    if ch3 == "A":  # Up arrow
+                        current = (current - 1) % n
+                        render()
+                    elif ch3 == "B":  # Down arrow
+                        current = (current + 1) % n
+                        render()
+            elif ch in ("k", "K"):
+                current = (current - 1) % n
+                render()
+            elif ch in ("j", "J"):
+                current = (current + 1) % n
+                render()
+            elif ch.isdigit():
+                idx = int(ch) - 1
+                if 0 <= idx < n:
+                    current = idx
+                    render()
+                    break
+            elif ch in ("\r", "\n", " "):
+                break
+            elif ch == "\x03":  # Ctrl+C
+                print("\033[?25h\n", end="")
+                sys.exit(0)
+    finally:
+        termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
+        print("\033[?25h", end="")  # Show cursor
+        sys.stdout.flush()
+
+    # Collapse into clean single confirmed line
+    print(f"\033[{n+1}A\r\033[K\033[32m✔\033[0m \033[1m{question}\033[0m \033[36m{choices[current]}\033[0m\n", end="")
+    for _ in range(n):
+        print("\033[K\n", end="")
+    print(f"\033[{n}A", end="")
+    sys.stdout.flush()
+
+    return choices[current]
+
+
+def prompt_string(question: str, default_val: str = "") -> str:
+    """Prompt for text input with a default fallback."""
+    if not sys.stdin.isatty():
+        print(f"\033[32m✔\033[0m \033[1m{question}\033[0m \033[36m{default_val}\033[0m")
+        return default_val
+
+    hint = f" \033[90m[{default_val}]\033[0m" if default_val else ""
+    try:
+        print(f"\n\033[1;37m? {question}\033[0m{hint}: ", end="")
+        sys.stdout.flush()
+        user_input = sys.stdin.readline().strip()
+        val = user_input if user_input else default_val
+        print(f"\033[1A\r\033[K\033[32m✔\033[0m \033[1m{question}\033[0m \033[36m{val}\033[0m\n", end="")
+        sys.stdout.flush()
+        return val
+    except (EOFError, KeyboardInterrupt):
+        print("\n", end="")
+        sys.exit(0)
+
+
+def prompt_bool(question: str, default_val: bool = True) -> bool:
+    """Prompt for Yes/No using arrow-key selection."""
+    choices = ["Yes", "No"] if default_val else ["No", "Yes"]
+    selected = prompt_choice(question, choices, default_idx=0)
+    return selected == "Yes"
+
+
+def run_interactive_wizard(hw_info: HardwareInfo) -> Dict[str, Any]:
+    """Guides the user through setting up and launching FlexSDS serving."""
+    print("\n\033[1;37m--- FlexSDS Serving Wizard ---\033[0m")
+
+    # Step 1: Select Action
+    action = prompt_choice(
+        "Select action:",
+        ["Launch serving", "Detect hardware", "Benchmark & profile GPU"],
+        default_idx=0,
+    )
+
+    if action == "Detect hardware":
+        print(f"\n\033[32m✔ Hardware specs: {hw_info.summary()}\033[0m")
+        return {"action": "detect"}
+
+    if action == "Benchmark & profile GPU":
+        cost_model, profile_name = load_profile_for_hardware(hw_info)
+        print(f"\n\033[32m✔ Hardware profile loaded: {profile_name}\033[0m")
+        return {"action": "profile"}
+
+    # Step 2: Target & Draft Model Configuration
+    model_mode = prompt_choice(
+        "Model configuration:",
+        [
+            "Default: Qwen2.5-7B-AWQ + EAGLE-3.1",
+            "Custom Hugging Face model",
+        ],
+        default_idx=0,
+    )
+
+    if "Default" in model_mode:
+        target_model = "Qwen/Qwen2.5-7B-Instruct-AWQ"
+        draft_model = "duckhoi/qwen2.5-7b-eagle3.1-speculator"
+    else:
+        target_model = prompt_string(
+            "Target model ID or path:",
+            default_val="Qwen/Qwen2.5-7B-Instruct-AWQ",
+        )
+        draft_model = prompt_string(
+            "Draft speculator ID or path:",
+            default_val="duckhoi/qwen2.5-7b-eagle3.1-speculator",
+        )
+
+    platform_choice = prompt_choice("Serving platform:", PLATFORM_CHOICES, default_idx=0)
+    backend = "modal" if "Modal" in platform_choice else ("colab" if "Colab" in platform_choice else "local")
+    target_gpu = "L4"
+    if backend == "modal":
+        target_gpu = prompt_choice("Modal GPU:", ["L4", "A10G", "T4"], default_idx=0)
+    elif backend == "colab":
+        target_gpu = "T4"
+    preflight = evaluate_serving_preflight(target_model, draft_model, hw_info, backend, target_gpu)
+    print(preflight.report.summary())
+    preflight.require_safe()
+    report = preflight.report
+
+    # Compatibility Report Box (dynamically auto-resizes)
+    status_color = "\033[32m" if not report.oom_risk else "\033[31m"
+    status_text = "OK" if not report.oom_risk else "OOM RISK"
+    vram_detail = f"(~{report.total_vram_needed_mb/1024:.1f} GB needed / {report.free_vram_mb/1024:.1f} GB free)"
+    vocab_text = "Shared" if not report.use_heterogeneous_vocab else "Heterogeneous"
+
+    box_items = [
+        ("VRAM Status", f"{status_text}  {vram_detail}", status_color),
+        ("Speculation", report.draft_method, "\033[36m"),
+        ("Vocabulary", vocab_text, "\033[32m"),
+    ]
+    for warn in report.warnings:
+        box_items.append(("Warning", warn, "\033[33m"))
+
+    print("\n" + render_box("Compatibility Report", box_items))
+
+    colab_tunnel_url = ""
+    modal_deploy = False
+    if backend == "modal":
+        if not ModalServingRunner().check_credentials():
+            print("Modal credentials missing; use flexsds auth login securely before launch.")
+        mode_choice = prompt_choice("Modal deployment mode:",
+                                   ["Development (modal serve)", "Production (modal deploy)"], default_idx=0)
+        modal_deploy = "Production" in mode_choice
+
+    elif "Google Colab" in platform_choice:
+        backend = "colab"
+        gpu_choice = prompt_choice("Colab GPU:", ["T4", "A100 / L4"], default_idx=0)
+        target_gpu = "T4" if "T4" in gpu_choice else "L4"
+
+        colab_runner = ColabServingRunner()
+        instructions = colab_runner.get_colab_instructions(target_gpu=target_gpu)
+        print("\n\033[1;37mGoogle Colab Instructions:\033[0m")
+        for step in instructions["steps"]:
+            print(f"  \033[90m{step}\033[0m")
+        print(f"  Notebook URL: \033[34m{instructions['notebook_url']}\033[0m\n")
+
+        colab_tunnel_url = prompt_string("Paste Cloudflare tunnel URL (Enter to skip):", "")
+        if colab_tunnel_url:
+            print("\033[90mVerifying tunnel connection...\033[0m")
+            if colab_runner.verify_tunnel_health(colab_tunnel_url):
+                print("\033[32m✔ Cloudflare tunnel is reachable.\033[0m")
+            else:
+                print("\033[33m⚠ Endpoint not responding yet (model weights may still be loading).\033[0m")
+
+    else:
+        backend = "local"
+        if not hw_info.is_cuda_available:
+            print("\n\033[33m⚠ No NVIDIA CUDA GPU detected on this system.\033[0m")
+            print("  Modal or Google Colab is recommended for hardware acceleration.")
+        else:
+            print(f"\n\033[32m✔ Local GPU: {hw_info.device_name} ({hw_info.free_vram_gb} GB free)\033[0m")
+
+    # Step 5: HardwareAdaptive Optimization Engine
+    enable_adaptive = prompt_bool(
+        "Enable HardwareAdaptive engine?",
+        default_val=True,
+    )
+
+    # Step 6: Profile Mapping
+    cost_model, profile_name = load_profile_for_hardware(hw_info)
+    print(f"\033[32m✔ Linked hardware profile: {profile_name}\033[0m")
+
+    # Save serving configuration
+    config: Dict[str, Any] = {
+        "flexsds_version": "0.2.0-alpha",
+        "action": "serve",
+        "backend": backend,
+        "target_model": target_model,
+        "draft_model": draft_model,
+        "draft_method": report.draft_method,
+        "use_heterogeneous_vocab": report.use_heterogeneous_vocab,
+        "enable_adaptive": enable_adaptive,
+        "profile_applied": profile_name,
+        "target_gpu": target_gpu,
+        "colab_tunnel_url": colab_tunnel_url,
+        "modal_deploy": modal_deploy,
+        "hardware": {
+            "device_name": hw_info.device_name,
+            "sm_architecture": hw_info.sm_architecture,
+            "free_vram_mb": hw_info.free_vram_mb,
+        },
+    }
+
+    config_file = Path("serving_config.json")
+    with open(config_file, "w", encoding="utf-8") as f:
+        json.dump(config, f, indent=2, ensure_ascii=False)
+    print(f"\033[32m✔ Configuration saved: {config_file.name}\033[0m")
+
+    # Step 7: Launch Server
+    should_launch = prompt_bool("Launch server now?", default_val=True)
+    if should_launch:
+        if backend == "local":
+            local_runner = LocalServingRunner()
+            run_in_bg = prompt_bool("Run server in background?", default_val=False)
+            proc = local_runner.launch(config, background=run_in_bg)
+            config["exit_code"] = finish_launch(proc, background=run_in_bg)
+            return config
+        elif backend == "modal":
+            modal_runner = ModalServingRunner()
+            proc = modal_runner.launch(config, deploy=modal_deploy)
+            config["exit_code"] = finish_launch(proc)
+            return config
+        elif backend == "colab":
+            endpoint = colab_tunnel_url or "http://localhost:8000/v1"
+            print("\n\033[1;32mColab guidance only; no server or endpoint created.\033[0m")
+            print(f"  \033[1;37mGợi ý:\033[0m Chạy lệnh: \033[36mflexsds chat --endpoint {endpoint}\033[0m để bắt đầu trò chuyện!\n")
+    else:
+        print("\n\033[1;32mConfiguration saved; no server launched or readiness established.\033[0m")
+        print("  \033[1;37mGợi ý:\033[0m Chạy \033[36mflexsds chat\033[0m để kết nối máy chủ khi đã bật.\n")
+
+    return config

flexsds/client/__init__.py

@@ -0,0 +1,4 @@
+"""FlexSDS client modules."""
+from flexsds.client.client import FlexSDSClient, EndpointUnreachableError
+
+__all__ = ["FlexSDSClient", "EndpointUnreachableError"]

flexsds/client/chat.py

@@ -0,0 +1,137 @@
+"""Interactive terminal chat session with real-time streaming and performance box."""
+from __future__ import annotations
+
+import sys
+
+try:
+    from flexsds.cli.output import print_output as print, write_output
+except ModuleNotFoundError:
+    from src.flexsds.cli.output import print_output as print, write_output
+import time
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional
+
+try:
+    from flexsds.client.client import FlexSDSClient, EndpointUnreachableError
+    from flexsds.cli.wizard import render_box
+except ModuleNotFoundError:
+    from src.flexsds.client.client import FlexSDSClient, EndpointUnreachableError
+    from src.flexsds.cli.wizard import render_box
+
+
+@dataclass
+class PerformanceMetrics:
+    """Performance measurements for one generation turn."""
+    total_chunks: int
+    elapsed_seconds: float
+
+    @property
+    def chunks_per_second(self) -> float:
+        if self.elapsed_seconds <= 0 or self.total_chunks == 0:
+            return 0.0
+        return round(self.total_chunks / self.elapsed_seconds, 2)
+
+    @property
+    def ms_per_chunk(self) -> float:
+        """Elapsed milliseconds per SSE content chunk; not TPOT."""
+        if self.total_chunks == 0 or self.elapsed_seconds <= 0:
+            return 0.0
+        return round((self.elapsed_seconds / self.total_chunks) * 1000.0, 2)
+
+
+class InteractiveChatSession:
+    """Manages multi-turn streaming chat on the terminal."""
+
+    def __init__(
+        self,
+        client: FlexSDSClient,
+        model: Optional[str] = None,
+        temperature: float = 0.0,
+    ) -> None:
+        self.client = client
+        self.model = model or "qwen2.5-7b-adaptive"
+        self.temperature = temperature
+        self.history: List[Dict[str, str]] = []
+
+    def start(self) -> int:
+        """Runs the interactive chat loop."""
+        if not self.client.check_health():
+            print(f"\n\033[31m[Lỗi kết nối]\033[0m Không thể kết nối tới máy chủ tại: {self.client.base_url}")
+            print("  Vui lòng đảm bảo máy chủ đã được bật bằng lệnh: flexsds serve")
+            return 1
+
+        print(f"\n\033[1;32m✔ Đã kết nối tới FlexSDS Serving Endpoint:\033[0m \033[36m{self.client.base_url}\033[0m")
+        print(f"  Mô hình: \033[1;37m{self.model}\033[0m | Đầu cơ: \033[33mEAGLE-3.1 (Adaptive k động)\033[0m")
+        print("  \033[90m(Gõ tin nhắn để trò chuyện, '/exit' để thoát, '/clear' để xóa ngữ cảnh)\033[0m\n")
+
+        while True:
+            try:
+                user_input = input("\033[1;32mYou >\033[0m ").strip()
+            except (KeyboardInterrupt, EOFError):
+                print("\n\033[90mPhiên trò chuyện kết thúc.\033[0m")
+                return 0
+
+            if not user_input:
+                continue
+
+            if user_input.lower() in ("/exit", "/quit", "exit", "quit"):
+                print("\033[90mPhiên trò chuyện kết thúc.\033[0m")
+                return 0
+
+            if user_input.lower() == "/clear":
+                self.history.clear()
+                print("\033[32m✔ Đã xóa lịch sử ngữ cảnh trò chuyện.\033[0m\n")
+                continue
+
+            self.history.append({"role": "user", "content": user_input})
+            write_output("\033[1;36mFlexSDS >\033[0m ")
+            sys.stdout.flush()
+
+            start_t = time.perf_counter()
+            chunk_count = 0
+            full_response: List[str] = []
+
+            try:
+                for token in self.client.stream_chat(
+                    self.history,
+                    model=self.model,
+                    temperature=self.temperature,
+                ):
+                    write_output(token)
+                    sys.stdout.flush()
+                    full_response.append(token)
+                    chunk_count += 1
+                write_output("\n")
+                sys.stdout.flush()
+            except KeyboardInterrupt:
+                write_output("\n\033[90m(Hủy lượt trả lời hiện tại)\033[0m\n")
+                sys.stdout.flush()
+                continue
+            except EndpointUnreachableError as e:
+                print(f"\n\033[31m[Lỗi đường truyền]\033[0m Mất kết nối tới server: {e}")
+                continue
+
+            elapsed = max(time.perf_counter() - start_t, 0.001)
+            metrics = PerformanceMetrics(total_chunks=chunk_count, elapsed_seconds=elapsed)
+            self.history.append({"role": "assistant", "content": "".join(full_response)})
+
+            # Render box thống kê hiệu năng
+            items = [
+                ("SSE content chunks", f"{metrics.total_chunks} chunks", "\033[1;37m"),
+                ("Thời gian xử lý", f"{metrics.elapsed_seconds:.2f} s", "\033[36m"),
+                ("Tốc độ trung bình", f"{metrics.chunks_per_second} chunks/s", "\033[32m"),
+                ("Elapsed per chunk", f"{metrics.ms_per_chunk} ms/chunk", "\033[33m"),
+            ]
+            box = render_box("Thống kê suy luận", items, min_width=44)
+            print(f"\n{box}\n")
+
+
+def run_interactive_chat(
+    endpoint: str = "http://localhost:8000/v1",
+    model: Optional[str] = None,
+    temperature: float = 0.0,
+) -> int:
+    """Entry point for CLI flexsds chat command."""
+    client = FlexSDSClient(base_url=endpoint)
+    session = InteractiveChatSession(client, model=model, temperature=temperature)
+    return session.start()

flexsds/client/client.py

@@ -0,0 +1,107 @@
+"""Lightweight OpenAI-compatible HTTP client with streaming SSE support."""
+from __future__ import annotations
+
+import json
+import urllib.error
+import urllib.request
+from typing import Any, Dict, Iterator, List, Optional
+
+
+class EndpointUnreachableError(Exception):
+    """Raised when the serving endpoint cannot be reached."""
+
+
+class FlexSDSClient:
+    """Client for OpenAI-compatible vLLM serving endpoints."""
+
+    base_url: str
+    api_key: str
+
+    def __init__(self, base_url: str = "http://localhost:8000/v1", api_key: Optional[str] = None) -> None:
+        self.base_url = base_url.rstrip("/")
+        self.api_key = api_key or "EMPTY"
+
+    def _make_request(
+        self,
+        endpoint: str,
+        data: Optional[Dict[str, Any]] = None,
+        timeout: Optional[int] = 10,
+    ) -> urllib.request.Request:
+        url = f"{self.base_url}/{endpoint.lstrip('/')}"
+        headers = {
+            "Content-Type": "application/json",
+            "User-Agent": "FlexSDS-Client/0.2.0",
+        }
+        if self.api_key and self.api_key != "EMPTY":
+            headers["Authorization"] = f"Bearer {self.api_key}"
+
+        body = json.dumps(data).encode("utf-8") if data is not None else None
+        return urllib.request.Request(url, data=body, headers=headers)
+
+    def check_health(self, timeout: int = 3) -> bool:
+        """Kiểm tra xem máy chủ có phản hồi không (qua /models hoặc /health)."""
+        # Thử endpoint models trước
+        try:
+            req = self._make_request("models", timeout=timeout)
+            with urllib.request.urlopen(req, timeout=timeout) as resp:
+                return resp.status == 200
+        except Exception:
+            pass
+
+        # Thử endpoint root health
+        try:
+            root_url = self.base_url.rsplit("/v1", 1)[0]
+            req = urllib.request.Request(f"{root_url}/health", headers={"User-Agent": "FlexSDS-Client/0.2.0"})
+            with urllib.request.urlopen(req, timeout=timeout) as resp:
+                return resp.status == 200
+        except Exception:
+            return False
+
+    def get_models(self) -> List[str]:
+        """Lấy danh sách các mô hình đang được phục vụ trên máy chủ."""
+        req = self._make_request("models")
+        try:
+            with urllib.request.urlopen(req, timeout=10) as resp:
+                data = json.loads(resp.read().decode("utf-8"))
+                return [m["id"] for m in data.get("data", [])]
+        except Exception as e:
+            raise EndpointUnreachableError(f"Cannot reach server at {self.base_url}: {e}") from e
+
+    def stream_chat(
+        self,
+        messages: List[Dict[str, str]],
+        model: str = "qwen2.5-7b-adaptive",
+        temperature: float = 0.0,
+    ) -> Iterator[str]:
+        """Gửi yêu cầu trò chuyện và trả về từng token văn bản (streaming SSE)."""
+        payload = {
+            "model": model,
+            "messages": messages,
+            "temperature": temperature,
+            "stream": True,
+        }
+        req = self._make_request("chat/completions", data=payload)
+
+        try:
+            resp = urllib.request.urlopen(req)
+        except Exception as e:
+            raise EndpointUnreachableError(f"Failed to connect to {self.base_url}: {e}") from e
+
+        with resp:
+            for raw_line in resp:
+                line = raw_line.decode("utf-8").strip()
+                if not line or not line.startswith("data: "):
+                    continue
+                chunk_str = line[6:].strip()
+                if chunk_str == "[DONE]":
+                    break
+                try:
+                    chunk = json.loads(chunk_str)
+                    choices = chunk.get("choices", [])
+                    if choices:
+                        delta = choices[0].get("delta", {})
+                        content = delta.get("content")
+                        if content:
+                            yield content
+                except json.JSONDecodeError:
+                    continue