pysfi 0.1.7__py3-none-any.whl → 0.1.11__py3-none-any.whl

sfi/llmserver/llmserver.py

@@ -0,0 +1,335 @@
+from __future__ import annotations
+
+import atexit
+import json
+import logging
+import os
+import pathlib
+import sys
+from pathlib import Path
+from types import SimpleNamespace
+from typing import ClassVar
+
+from PySide2.QtCore import QProcess, QTextStream, QUrl
+from PySide2.QtGui import (
+    QBrush,
+    QColor,
+    QDesktopServices,
+    QFont,
+    QMoveEvent,
+    QResizeEvent,
+    QTextCharFormat,
+    QTextCursor,
+)
+from PySide2.QtWidgets import (
+    QApplication,
+    QFileDialog,
+    QGroupBox,
+    QHBoxLayout,
+    QLabel,
+    QLineEdit,
+    QMainWindow,
+    QPushButton,
+    QSpinBox,
+    QTextEdit,
+    QVBoxLayout,
+    QWidget,
+)
+
+CONFIG_FILE = Path.home() / ".sfi" / "llmserver.json"
+logging.basicConfig(level="INFO", format="%(message)s")
+logger = logging.getLogger(__name__)
+
+
+class LLMServerConfig(SimpleNamespace):
+    """Llama local model server configuration."""
+
+    TITLE: str = "Llama Local Model Server"
+    WIN_SIZE: ClassVar[list[int]] = [800, 800]
+    WIN_POS: ClassVar[list[int]] = [200, 200]
+    MODEL_PATH: str = ""
+
+    URL: str = "http://127.0.0.1"
+    LISTEN_PORT: int = 8080
+    LISTEN_PORT_RNG: ClassVar[list[int]] = [1024, 65535]
+    THREAD_COUNT_RNG: ClassVar[list[int]] = [1, 24]
+    THREAD_COUNT: int = 4
+
+    def __init__(self) -> None:
+        if CONFIG_FILE.exists():
+            logger.info("Loading configuration from %s", CONFIG_FILE)
+            self.__dict__.update(json.loads(CONFIG_FILE.read_text()))
+        else:
+            logger.info("Using default configuration")
+
+    def save(self) -> None:
+        """Save configuration."""
+        CONFIG_FILE.parent.mkdir(parents=True, exist_ok=True)
+        CONFIG_FILE.write_text(json.dumps(vars(self), indent=4))
+
+
+conf = LLMServerConfig()
+atexit.register(conf.save)
+
+
+class LlamaServerGUI(QMainWindow):
+    """Llama local model server GUI."""
+
+    # Color constants
+    COLOR_ERROR = QColor(255, 0, 0)
+    COLOR_WARNING = QColor(255, 165, 0)
+    COLOR_INFO = QColor(0, 0, 0)
+
+    # Process constants
+    PROCESS_TERMINATE_TIMEOUT_MS = 2000
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.setWindowTitle(conf.TITLE)
+        self.setGeometry(*conf.WIN_POS, *conf.WIN_SIZE)
+
+        self.process: QProcess
+        self.init_ui()
+        self.setup_process()
+
+        model_path = conf.MODEL_PATH
+        if model_path:
+            self.model_path_input.setText(str(model_path))
+        else:
+            self.model_path_input.setPlaceholderText("Choose model file...")
+
+    def init_ui(self) -> None:
+        """Initialize user interface."""
+        # Main layout
+        main_widget = QWidget()
+        main_layout = QVBoxLayout()  # type: ignore
+
+        # Configuration panel
+        config_group = QGroupBox("Server Configuration")
+        config_layout = QVBoxLayout(config_group)
+
+        # Model path selection
+        model_path_layout = QHBoxLayout()  # type: ignore
+        model_path_layout.addWidget(QLabel("Model Path:"))
+        self.model_path_input = QLineEdit()
+
+        model_path_layout.addWidget(self.model_path_input)
+        self.load_model_btn = QPushButton("Browse...")
+        self.load_model_btn.clicked.connect(self.on_load_model)  # type: ignore
+        model_path_layout.addWidget(self.load_model_btn)
+        config_layout.addLayout(model_path_layout)
+
+        # Server parameters
+        params_layout = QHBoxLayout()  # type: ignore
+        params_layout.addStretch(1)
+        params_layout.addWidget(QLabel("Port:"))
+        self.port_spin = QSpinBox()
+        self.port_spin.setRange(*conf.LISTEN_PORT_RNG)
+        self.port_spin.setValue(conf.LISTEN_PORT)
+        params_layout.addWidget(self.port_spin)
+        self.port_spin.valueChanged.connect(self.on_config_changed)  # type: ignore
+
+        params_layout.addWidget(QLabel("Threads:"))
+        self.threads_spin = QSpinBox()
+        self.threads_spin.setRange(*conf.THREAD_COUNT_RNG)
+        self.threads_spin.setValue(conf.THREAD_COUNT)
+        params_layout.addWidget(self.threads_spin)
+        config_layout.addLayout(params_layout)
+        self.threads_spin.valueChanged.connect(self.on_config_changed)  # type: ignore
+
+        config_group.setLayout(config_layout)
+        main_layout.addWidget(config_group)
+
+        # Control buttons
+        control_layout = QHBoxLayout()  # type: ignore
+        self.start_btn = QPushButton("Start Server")
+        self.start_btn.clicked.connect(self.toggle_server)  # type: ignore
+        self.browser_btn = QPushButton("Start Browser")
+        self.browser_btn.setEnabled(False)
+        self.browser_btn.clicked.connect(self.on_start_browser)  # type: ignore
+        control_layout.addWidget(self.start_btn)
+        control_layout.addWidget(self.browser_btn)
+        main_layout.addLayout(control_layout)
+
+        # Output display
+        output_group = QGroupBox("Server Output")
+        output_layout = QVBoxLayout(output_group)
+        self.output_area = QTextEdit("")
+        self.output_area.setReadOnly(True)
+        self.output_area.setLineWrapMode(QTextEdit.NoWrap)  # type: ignore
+
+        # Set colors for different message types
+        self.error_format = self.create_text_format(self.COLOR_ERROR)
+        self.warning_format = self.create_text_format(self.COLOR_WARNING)
+        self.info_format = self.create_text_format(self.COLOR_INFO)
+
+        output_layout.addWidget(self.output_area)
+        output_group.setLayout(output_layout)
+        main_layout.addWidget(output_group)
+
+        main_widget.setLayout(main_layout)
+        self.setCentralWidget(main_widget)
+
+    @staticmethod
+    def create_text_format(color: QColor) -> QTextCharFormat:
+        """Create text format.
+
+        Args:
+            color: Text color.
+
+        Returns:
+            Text format.
+        """
+        text_format = QTextCharFormat()
+        text_format.setForeground(QBrush(color))
+        return text_format
+
+    def setup_process(self) -> None:
+        """Initialize process."""
+        self.process = QProcess(self)
+        self.process.readyReadStandardOutput.connect(self.handle_stdout)  # type: ignore
+        self.process.readyReadStandardError.connect(self.handle_stderr)  # type: ignore
+        self.process.finished.connect(self.on_process_finished)  # type: ignore
+
+    def on_config_changed(self) -> None:
+        """Configuration changed."""
+        conf.MODEL_PATH = self.model_path_input.text().strip()
+        conf.LISTEN_PORT = self.port_spin.value()
+        conf.THREAD_COUNT = self.threads_spin.value()
+        # Configuration will be saved on exit via atexit.register
+
+    def on_load_model(self) -> None:
+        """Select model file."""
+        initial_dir = (
+            conf.MODEL_PATH if os.path.exists(conf.MODEL_PATH) else str(Path.home())
+        )
+        path, _ = QFileDialog.getOpenFileName(
+            self,
+            "Select Model File",
+            initial_dir,
+            "Model Files (*.bin *.gguf)",
+        )
+
+        if path:
+            conf.MODEL_PATH = path
+            self.model_path_input.setText(os.path.normpath(path))
+
+    def toggle_server(self) -> None:
+        """Start or stop server."""
+        if self.process.state() == QProcess.Running:
+            self.stop_server()
+        else:
+            self.start_server()
+
+    def start_server(self) -> None:
+        """Start server."""
+        model_path = pathlib.Path(self.model_path_input.text().strip())
+        if not model_path.exists():
+            self.append_output(
+                "Error: Invalid model file path\n",
+                self.error_format,
+            )
+            return
+
+        os.chdir(str(model_path.parent))
+        cmd = [
+            "llama-server",
+            "--model",
+            model_path.name,
+            "--port",
+            str(self.port_spin.value()),
+            "--threads",
+            str(self.threads_spin.value()),
+        ]
+
+        self.append_output(f"Start: {' '.join(cmd)}\n", self.info_format)
+
+        try:
+            self.process.start(cmd[0], cmd[1:])
+            self.update_ui_state(running=True)
+        except Exception as e:
+            self.append_output(f"Start failed: {e!s}\n", self.error_format)
+
+    def stop_server(self) -> None:
+        """Stop server."""
+        if self.process.state() == QProcess.Running:
+            self.append_output("Stopping server...\n", self.info_format)
+            self.process.terminate()
+            if not self.process.waitForFinished(self.PROCESS_TERMINATE_TIMEOUT_MS):
+                self.process.kill()
+
+    @staticmethod
+    def on_start_browser() -> None:
+        """Start browser."""
+        QDesktopServices.openUrl(QUrl(f"{conf.URL}:{conf.LISTEN_PORT}"))
+
+    def on_process_finished(self, exit_code: int, exit_status: int) -> None:
+        """Process finished."""
+        self.append_output(
+            f"\nServer stopped, Exit code: {exit_code}, Status: {exit_status}\n",
+            self.info_format,
+        )
+        self.update_ui_state(running=False)
+
+    def handle_stdout(self) -> None:
+        """Handle standard output."""
+        data = self.process.readAllStandardOutput()
+        text = QTextStream(data).readAll()
+        self.append_output(text, self.info_format)
+
+    def handle_stderr(self) -> None:
+        """Handle standard error."""
+        data = self.process.readAllStandardError()
+        text = QTextStream(data).readAll()
+        self.append_output(text, self.error_format)
+
+    def append_output(
+        self,
+        text: str,
+        text_format: QTextCharFormat | None = None,
+    ) -> None:
+        """Append output."""
+        cursor: QTextCursor = self.output_area.textCursor()
+        cursor.movePosition(QTextCursor.MoveOperation.End)
+
+        if text_format:
+            cursor.setCharFormat(text_format)
+
+        cursor.insertText(text)
+
+        self.output_area.setTextCursor(cursor)
+        self.output_area.ensureCursorVisible()
+
+    def update_ui_state(self, *, running: bool) -> None:
+        """Update UI state."""
+        self.model_path_input.setEnabled(not running)
+        self.load_model_btn.setEnabled(not running)
+        self.port_spin.setEnabled(not running)
+        self.threads_spin.setEnabled(not running)
+        self.browser_btn.setEnabled(running)
+
+        if running:
+            self.start_btn.setText("Stop Server")
+        else:
+            self.start_btn.setText("Start Server")
+
+    def moveEvent(self, event: QMoveEvent) -> None:  # noqa: N802
+        """Handle window move event."""
+        top_left = self.geometry().topLeft()
+        conf.WIN_POS = [top_left.x(), top_left.y()]
+        return super().moveEvent(event)
+
+    def resizeEvent(self, event: QResizeEvent) -> None:  # noqa: N802
+        """Handle window resize event."""
+        geometry = self.geometry()
+        conf.WIN_SIZE = [geometry.width(), geometry.height()]
+        return super().resizeEvent(event)
+
+
+def main() -> None:
+    """Main entry point."""
+    app = QApplication(sys.argv)
+    app.setFont(QFont("Consolas", 12))
+    window = LlamaServerGUI()
+    window.show()
+    sys.exit(app.exec_())

sfi/makepython/makepython.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import argparse
-import json
 import logging
 import os
 import shutil
@@ -35,8 +34,12 @@ def parse_pyproject_toml(directory: Path) -> dict:
         logger.error(f"No pyproject.toml found in {directory}")
         return {}
 
-    with project_toml.open("rb") as f:
-        return tomllib.load(f)
+    try:
+        with project_toml.open("rb") as f:
+            return tomllib.load(f)
+    except Exception as e:
+        logger.error(f"Error parsing pyproject.toml: {e}")
+        return {}
 
 
 def _get_build_command_from_toml(directory: Path) -> str | None:
@@ -59,12 +62,11 @@ def _get_build_command_from_toml(directory: Path) -> str | None:
                 logger.error(f"Unknown build-backend: {build_backend}")
                 return None
 
-    logger.error("No `build-system` or `build-backend` found in pyproject.toml: ")
-    logger.error(json.dumps(project_data, indent=2, ensure_ascii=False, sort_keys=True))
+    logger.error("No `build-system` or `build-backend` found in pyproject.toml")
     return None
 
 
-def _get_build_command(directory: Path):
+def _get_build_command(directory: Path) -> str | None:
     """Get build command from directory."""
     project_path = directory / "pyproject.toml"
     if project_path.is_file():
@@ -87,39 +89,38 @@ class Command:
     cmds: list[str] | Callable[..., Any] | None = None
 
 
-def _clean(root_dir: Path):
+def _clean(root_dir: Path = cwd):
     _run_command(["rm", "-rf", "dist", "build", "*.egg-info"], root_dir)
 
 
-BUILD_COMMAND = _get_build_command(cwd) or ""
-_COMMANDS = [
-    Command(name="build", alias="b", cmds=[BUILD_COMMAND, "build"]),
-    Command(name="bumpversion", alias="bump", cmds=["bumpversion", "patch"]),
-    Command(name="clean", alias="c", cmds=_clean),
-    Command(name="publish", alias="p"),  # No preset commands
-    Command(name="test", alias="t", cmds=lambda: os.system("pytest")),
-    Command(name="test-benchmark", alias="tb", cmds=lambda: os.system("pytest -m benchmark")),
-    Command(name="test-coverage", alias="tc", cmds=lambda: os.system("pytest --cov=sfi")),
-    Command(name="token", alias="tk", cmds=lambda: _set_token(BUILD_COMMAND)),
-]
-_COMMAND_DICT = {command.name: command for command in _COMMANDS}
-_COMMAND_DICT.update({command.alias: command for command in _COMMANDS})
-_CHOICES = [command.alias for command in _COMMANDS]
-_CHOICES.extend([command.name for command in _COMMANDS])
-
-
-def main():
+def main() -> None:
+    # Get build command
+    build_command = _get_build_command(cwd) or ""
+    commands = [
+        Command(name="build", alias="b", cmds=[build_command, "build"]),
+        Command(name="bumpversion", alias="bump", cmds=["bumpversion", "patch", "--tag"]),
+        Command(name="clean", alias="c", cmds=_clean),
+        Command(name="publish", alias="p"),  # No preset commands
+        Command(name="test", alias="t", cmds=lambda: os.system("pytest")),
+        Command(name="test-benchmark", alias="tb", cmds=lambda: os.system("pytest -m benchmark")),
+        Command(name="test-coverage", alias="tc", cmds=lambda: os.system("pytest --cov=sfi")),
+        Command(name="token", alias="tk", cmds=lambda: _set_token(build_command)),
+    ]
+    command_dict = {command.name: command for command in commands}
+    command_dict.update({command.alias: command for command in commands})
+    choices = [command.alias for command in commands]
+    choices.extend([command.name for command in commands])
+
+    # Parse args
     parser = argparse.ArgumentParser(description="Make Python")
-    parser.add_argument("command", type=str, choices=_CHOICES, help=f"Command to run, options: {_CHOICES}")
     parser.add_argument("--debug", "-d", action="store_true", help="Enable debug mode")
-
+    parser.add_argument("command", type=str, choices=choices, help=f"Command to run, options: {choices}")
     args = parser.parse_args()
     if args.debug:
         logger.setLevel(logging.DEBUG)
 
-    build_command = _get_build_command(cwd) or ""
-    logger.info(f"Using build command: {build_command}")
-    command = _COMMAND_DICT.get(args.command)
+    logger.debug(f"Using build command: {build_command}")
+    command = command_dict.get(args.command)
     if command:
         if callable(command.cmds):
             command.cmds()