pygpt-net 2.6.60__py3-none-any.whl → 2.6.61__py3-none-any.whl

pygpt_net/tools/agent_builder/ui/dialogs.py

@@ -11,7 +11,7 @@
 
 from PySide6.QtCore import Qt, QEvent
 from PySide6.QtGui import QAction, QIcon
-from PySide6.QtWidgets import QVBoxLayout, QMenuBar, QSplitter, QSizePolicy
+from PySide6.QtWidgets import QVBoxLayout, QMenuBar, QSplitter, QSizePolicy, QWidget
 
 from pygpt_net.ui.widget.element.labels import HelpLabel
 from pygpt_net.ui.widget.node_editor.editor import NodeEditor
@@ -41,13 +41,13 @@ class Builder:
         self.file_menu = self.menu_bar.addMenu(trans("menu.file"))
         t = self.tool
 
-        self.actions["open"] = QAction(QIcon(":/icons/reload.svg"), "Reload", self.menu_bar)
+        self.actions["open"] = QAction(QIcon(":/icons/reload.svg"), trans("action.reload"), self.menu_bar)
         self.actions["open"].triggered.connect(lambda checked=False, t=t: t.load())
 
         self.actions["save"] = QAction(QIcon(":/icons/save.svg"), trans("action.save"), self.menu_bar)
         self.actions["save"].triggered.connect(lambda checked=False, t=t: t.save())
 
-        self.actions["clear"] = QAction(QIcon(":/icons/clear.svg"), trans("action.clear"), self.menu_bar)
+        self.actions["clear"] = QAction(QIcon(":/icons/close.svg"), trans("action.clear"), self.menu_bar)
         self.actions["clear"].triggered.connect(lambda checked=False, t=t: t.clear())
 
         self.file_menu.addAction(self.actions["open"])
@@ -77,7 +77,28 @@ class Builder:
             registry=registry
         )  # parent == dialog
 
-        editor.setStyleSheet("""
+        theme = self.window.core.config.get("theme")
+        if theme.startswith("light"):
+            style = """
+            NodeEditor {
+                qproperty-gridBackColor: #ffffff;
+                qproperty-gridPenColor:  #eaeaea;
+
+                qproperty-nodeBackgroundColor: #2d2f34;
+                qproperty-nodeBorderColor:     #4b4f57;
+                qproperty-nodeSelectionColor:  #ff9900;
+                qproperty-nodeTitleColor:      #3a3d44;
+
+                qproperty-portInputColor:      #66b2ff;
+                qproperty-portOutputColor:     #70e070;
+                qproperty-portConnectedColor:  #ffd166;
+
+                qproperty-edgeColor:           #c0c0c0;
+                qproperty-edgeSelectedColor:   #ff8a5c;
+            }
+            """
+        else:
+            style = """
             NodeEditor {
                 qproperty-gridBackColor: #242629;
                 qproperty-gridPenColor:  #3b3f46;
@@ -94,8 +115,10 @@ class Builder:
                 qproperty-edgeColor:           #c0c0c0;
                 qproperty-edgeSelectedColor:   #ff8a5c;
             }
-            """)
+            """
+        editor.setStyleSheet(style)
         editor.on_clear = self.tool.clear
+        editor.editing_allowed = self.tool.editing_allowed
 
         u.editor[id] = editor
 
@@ -104,9 +127,28 @@ class Builder:
 
         agents_list = AgentsWidget(self.window, tool=self.tool, parent=dlg)
         list_widget = agents_list.setup()
-        list_widget.setFixedWidth(250)
+
+        # Left side container: list fills all space, help label stays at the bottom
+        left_side = QWidget(dlg)
+        left_layout = QVBoxLayout(left_side)
+        left_layout.setContentsMargins(0, 0, 0, 0)
+        left_layout.setSpacing(6)
+
+        left_help_label = HelpLabel(trans("node.editor.list.tip"))
+        left_help_label.setWordWrap(True)
+        left_help_label.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
+        left_help_label.setTextInteractionFlags(Qt.TextSelectableByMouse)
+        left_help_label.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Minimum)
+
+        left_layout.addWidget(list_widget)
+        left_layout.addWidget(left_help_label)
+        left_layout.setStretch(0, 1)  # list -> fills all vertical space
+
+        # Fix the width of the whole left panel (not only the list)
+        left_side.setFixedWidth(250)
+
         center_splitter = QSplitter(Qt.Horizontal)
-        center_splitter.addWidget(list_widget)
+        center_splitter.addWidget(left_side)
         center_splitter.addWidget(u.editor[id])
         center_splitter.setStretchFactor(0, 1)
         center_splitter.setStretchFactor(1, 8)
@@ -115,10 +157,7 @@ class Builder:
         layout.setStretch(0, 1)
 
         # Bottom legend as a compact, centered help label
-        legend_label = HelpLabel(
-            "Right-click: add node / undo / redo • Middle-click: pan view • Ctrl + Mouse wheel: zoom • "
-            "Left-click a port: create connection • Ctrl + Left-click a port: rewire or detach • Right-click or DEL a node/connection: remove"
-        )
+        legend_label = HelpLabel(trans("node.editor.bottom.tip"))
         legend_label.setAlignment(Qt.AlignCenter)
         legend_label.setWordWrap(True)
         legend_label.setTextInteractionFlags(Qt.TextSelectableByMouse)
@@ -129,6 +168,7 @@ class Builder:
         u.nodes["agent.builder.splitter"] = center_splitter
         u.nodes["agent.builder.list"] = agents_list
         u.nodes["agent.builder.legend"] = legend_label
+        u.nodes["agent.builder.list.help"] = left_help_label
 
         dlg.setLayout(layout)
         dlg.setWindowTitle(trans("agent.builder.title"))
@@ -231,6 +271,15 @@ class BuilderDialog(BaseDialog):
             except Exception:
                 pass
 
+        # Dispose left-side help label safely
+        try:
+            help_lbl = u.nodes.pop("agent.builder.list.help", None)
+            if help_lbl is not None:
+                help_lbl.setParent(None)
+                help_lbl.deleteLater()
+        except Exception:
+            pass
+
         # Drop splitter reference
         try:
             u.nodes.pop("agent.builder.splitter", None)

pygpt_net/ui/__init__.py

@@ -172,15 +172,13 @@ class UI:
 
     def show_loading(self):
         """Show loading"""
-        if self.window.core.config.get('layout.animation.disable', False):
-            return
+        return
         self.window.ui.nodes['anim.loading'].start_anim()
         self.window.ui.nodes['anim.loading'].show()
 
     def hide_loading(self):
         """Hide loading"""
-        if self.window.core.config.get('layout.animation.disable', False):
-            return
+        return
         self.window.ui.nodes['anim.loading'].stop_anim()
         self.window.ui.nodes['anim.loading'].hide()
 

pygpt_net/ui/dialog/about.py

@@ -19,6 +19,9 @@ from pygpt_net.utils import trans
 
 
 class About:
+
+    RELEASE_YEAR = 2025
+
     def __init__(self, window=None):
         """
         About dialog
@@ -36,34 +39,65 @@ class About:
         """
         return self.window.core.updater.get_fetch_thanks()
 
+    def build_versions_str(self, lib_versions: dict, break_after: str = "LlamaIndex") -> str:
+        parts = []
+        line = []
+        for k, v in lib_versions.items():
+            line.append(f"{k}: {v}")
+            if k == break_after:
+                parts.append(", ".join(line))
+                line = []
+        if line:
+            parts.append(", ".join(line))
+        return "\n".join(parts)
+
     def prepare_content(self) -> str:
         """
         Get info text
 
         :return: info text
         """
-        llama_index_version = None
-        langchain_version = None
-        openai_version = None
-        versions = True
+        lib_versions = {}
+
+        try:
+            import platform
+            lib_versions['Python'] = platform.python_version()
+        except ImportError:
+            pass
 
         try:
-            from llama_index.core import __version__ as llama_index_version
-            # from langchain import __version__ as langchain_version
             from openai.version import VERSION as openai_version
+            lib_versions['OpenAI API'] = openai_version
+        except ImportError:
+            pass
+
+        try:
+            from llama_index.core import __version__ as llama_index_version
+            lib_versions['LlamaIndex'] = llama_index_version
+        except ImportError:
+            pass
+
+        try:
+            from anthropic import __version__ as anthropic_version
+            lib_versions['Anthropic API'] = anthropic_version
+        except ImportError:
+            pass
+
+        try:
+            from google.genai import __version__ as google_genai_version
+            lib_versions['Google API'] = google_genai_version
         except ImportError:
             pass
 
-        lib_versions = ""
-        if llama_index_version is None or openai_version is None:
-            versions = False
+        try:
+            from xai_sdk import __version__ as xai_sdk_version
+            lib_versions['xAI API'] = xai_sdk_version
+        except ImportError:
+            pass
 
-        if versions:
-            lib_versions = "OpenAI API: {}, LlamaIndex: {}\n\n".format(
-                openai_version,
-                # langchain_version,
-                llama_index_version,
-            )
+        versions_str = ""
+        if lib_versions:
+            versions_str = self.build_versions_str(lib_versions, break_after="LlamaIndex")
 
         platform = self.window.core.platforms.get_as_string()
         version = self.window.meta['version']
@@ -80,29 +114,14 @@ class About:
         label_github = trans("dialog.about.github")
         label_docs = trans("dialog.about.docs")
 
-        data = "{label_version}: {version}, {platform}\n" \
-               "{label_build}: {build}\n" \
-               "{lib_versions}" \
-               "{label_website}: {website}\n" \
-               "{label_github}: {github}\n" \
-               "{label_docs}: {docs}\n\n" \
-               "(c) 2025 {author}\n" \
-               "{email}\n".format(
-                label_version=label_version,
-                version=version,
-                platform=platform,
-                label_build=label_build,
-                build=build.replace('.', '-'),
-                label_website=label_website,
-                website=website,
-                label_github=label_github,
-                github=github,
-                label_docs=label_docs,
-                docs=docs,
-                author=author,
-                email=email,
-                lib_versions=lib_versions,
-            )
+        data = f"{label_version}: {version}, {platform}\n" \
+               f"{label_build}: {build.replace('.', '-')}\n\n" \
+               f"{versions_str}\n\n" \
+               f"{label_website}: {website}\n" \
+               f"{label_github}: {github}\n" \
+               f"{label_docs}: {docs}\n\n" \
+               f"(c) {self.RELEASE_YEAR} {author}\n" \
+               f"{email}\n"
         return data
 
     def setup(self):
@@ -139,6 +158,7 @@ class About:
         string = self.prepare_content()
         content = QLabel(string)
         content.setTextInteractionFlags(Qt.TextSelectableByMouse)
+        content.setWordWrap(True)
         self.window.ui.nodes['dialog.about.content'] = content
 
         thanks = QLabel(trans('about.thanks'))

pygpt_net/ui/dialog/db.py

@@ -6,13 +6,13 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.09.05 18:00:00                  #
+# Updated Date: 2025.09.26 03:00:00                  #
 # ================================================== #
 
-from PySide6.QtCore import Qt, QTimer, QSignalBlocker
+from PySide6.QtCore import Qt, QTimer, QSignalBlocker, QObject, QEvent
 from PySide6.QtGui import QAction, QIcon, QIntValidator
 from PySide6.QtWidgets import QGridLayout, QScrollArea, QSplitter, QComboBox, QLineEdit, QPushButton, \
-    QHBoxLayout, QVBoxLayout, QLabel, QWidget, QSizePolicy, QCheckBox, QMenuBar, QAbstractItemView, QHeaderView, QStyledItemDelegate
+    QHBoxLayout, QVBoxLayout, QLabel, QWidget, QSizePolicy, QCheckBox, QMenuBar, QAbstractItemView, QHeaderView, QStyledItemDelegate, QMenu, QApplication
 
 from pygpt_net.ui.widget.dialog.db import DatabaseDialog
 from pygpt_net.ui.widget.lists.db import DatabaseList, DatabaseTableModel
@@ -32,6 +32,98 @@ class _FastTextDelegate(QStyledItemDelegate):
         return s
 
 
+class _ContextMenuStyler(QObject):
+    """
+    Ensures that any QMenu spawned from the observed widgets adopts the same
+    application stylesheet, palette and font (e.g. Qt Material), even if
+    the menu is created without a parent or uses platform defaults.
+    The filter is installed only on specific widgets (no app-wide filters).
+    """
+
+    def __init__(self, style_source: QWidget):
+        super().__init__(style_source)
+        self._source = style_source
+        self._scan_timer = QTimer(self)
+        self._scan_timer.setInterval(50)  # fast enough to catch freshly spawned menus
+        self._scan_timer.timeout.connect(self._scan_and_style)
+        self._scan_ticks = 0
+        self._scan_ticks_max = 8  # up to ~400ms window
+
+    def eventFilter(self, obj, event):
+        # Trigger styling round right before/around menu show moments
+        if event.type() in (QEvent.ContextMenu, QEvent.MouseButtonPress, QEvent.KeyPress):
+            if event.type() == QEvent.ContextMenu:
+                self._start_scan()
+            elif event.type() == QEvent.MouseButtonPress and hasattr(event, "button") and event.button() == Qt.RightButton:
+                self._start_scan()
+            elif event.type() == QEvent.KeyPress:
+                key = getattr(event, "key", lambda: None)()
+                mods = getattr(event, "modifiers", lambda: Qt.NoModifier)()
+                if key == Qt.Key_Menu or (key == Qt.Key_F10 and (mods & Qt.ShiftModifier)):
+                    self._start_scan()
+        return False  # do not consume events
+
+    def _start_scan(self):
+        # Start a short, repeated scan to reliably catch the menu top-level window
+        self._scan_ticks = 0
+        if not self._scan_timer.isActive():
+            # immediate pass + scheduled ones
+            QTimer.singleShot(0, self._scan_and_style)
+            self._scan_timer.start()
+
+    def _scan_and_style(self):
+        self._scan_ticks += 1
+        app = QApplication.instance()
+        if app is None:
+            self._scan_timer.stop()
+            return
+
+        found_any = False
+        for w in app.topLevelWidgets():
+            if isinstance(w, QMenu):
+                found_any = True
+                self._ensure_menu_style(w)
+
+        # Stop once we scanned enough frames, or if no menus appear after a short while
+        if self._scan_ticks >= self._scan_ticks_max or (self._scan_ticks >= 2 and not found_any):
+            self._scan_timer.stop()
+
+    def _ensure_menu_style(self, menu: QMenu):
+        # Avoid re-styling the same widget repeatedly
+        if bool(menu.property("_pygpt_menu_styled")):
+            return
+
+        app = QApplication.instance()
+        try:
+            # Apply application-level stylesheet (covers Qt Material CSS selectors for QMenu)
+            if app is not None:
+                ss = app.styleSheet()
+                if ss:
+                    # Assign directly to the menu; do not append, to avoid duplication on repeated shows
+                    menu.setStyleSheet(ss)
+
+            # Copy palette, font and style from the source window to guarantee readable contrast
+            src = self._source.window() if self._source is not None else None
+            if src is None and app is not None:
+                src = app.activeWindow()
+
+            if src is not None:
+                menu.setPalette(src.palette())
+                menu.setFont(src.font())
+                # Also align QStyle to prevent platform defaults from clashing with stylesheet
+                menu.setStyle(src.style())
+
+            # Mark as processed
+            menu.setProperty("_pygpt_menu_styled", True)
+
+            # Update to reflect changes immediately if the menu is already visible
+            if menu.isVisible():
+                menu.update()
+        except Exception:
+            # Fail-safe: never break the context menu on styling issues
+            pass
+
+
 class Database:
     def __init__(self, window=None):
         """
@@ -94,6 +186,9 @@ class Database:
         self.batch_actions_menu.addAction(self.delete_all_action)
         self.batch_actions_menu.addAction(self.truncate_action)
 
+        # Ensure QMenu used by menu bar follows the application/theme styling
+        self._apply_menu_style(self.batch_actions_menu)
+
         layout = QGridLayout()
         layout.addWidget(splitter, 1, 0)
         layout.setMenuBar(self.menu_bar)
@@ -102,6 +197,22 @@ class Database:
         self.window.ui.dialog['debug.db'].setLayout(layout)
         self.window.ui.dialog['debug.db'].setWindowTitle("Debug: Database (SQLite)")
 
+    def _apply_menu_style(self, menu: QMenu):
+        """Ensure QMenu follows application/theme styling consistently."""
+        try:
+            app = QApplication.instance()
+            if app is not None:
+                ss = app.styleSheet()
+                if ss:
+                    menu.setStyleSheet(ss)
+            if self.window is not None:
+                menu.setStyle(self.window.style())
+                menu.setPalette(self.window.palette())
+                menu.setFont(self.window.font())
+        except Exception:
+            # Never break UI if styling fails
+            pass
+
     def _on_splitter_moved(self, pos, index):
         if self._text_viewer is not None:
             self._text_viewer.setUpdatesEnabled(False)
@@ -267,6 +378,34 @@ class DataBrowser(QWidget):
         self.setLayout(main_layout)
 
         view = self.get_list_widget()
+
+        # Robust, local-only context menu styling (no app-wide filters)
+        self._menu_styler = _ContextMenuStyler(self.window if self.window is not None else self)
+        if hasattr(view, "installEventFilter"):
+            view.installEventFilter(self._menu_styler)
+        # Context menu usually originates from the viewport in item views
+        if hasattr(view, "viewport") and callable(view.viewport):
+            vp = view.viewport()
+            if vp is not None and hasattr(vp, "installEventFilter"):
+                vp.installEventFilter(self._menu_styler)
+        # Also watch headers (they may expose their own context menus)
+        if hasattr(view, "horizontalHeader"):
+            hh = view.horizontalHeader()
+            if hh is not None:
+                hh.installEventFilter(self._menu_styler)
+                if hasattr(hh, "viewport"):
+                    hvp = hh.viewport()
+                    if hvp is not None:
+                        hvp.installEventFilter(self._menu_styler)
+        if hasattr(view, "verticalHeader"):
+            vh = view.verticalHeader()
+            if vh is not None:
+                vh.installEventFilter(self._menu_styler)
+                if hasattr(vh, "viewport"):
+                    vvp = vh.viewport()
+                    if vvp is not None:
+                        vvp.installEventFilter(self._menu_styler)
+
         if hasattr(view, "setUniformRowHeights"):
             view.setUniformRowHeights(True)
         if hasattr(view, "setWordWrap"):

pygpt_net/ui/dialog/preset.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.08.28 09:00:00                  #
+# Updated Date: 2025.09.25 13:04:51                  #
 # ================================================== #
 
 from PySide6.QtCore import Qt
@@ -156,6 +156,8 @@ class Preset(BaseConfigDialog):
         modes = QWidget()
         modes.setLayout(rows_mode)
         modes.setContentsMargins(0, 0, 0, 0)
+        # Ensure modes column never grows taller than its content; avoids creating vertical gap above the splitter.
+        modes.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Maximum)
         self.window.ui.nodes['preset.editor.modes'] = modes
 
         # experts
@@ -208,7 +210,7 @@ class Preset(BaseConfigDialog):
                 # special case with settings icon on right
                 node_layout = QHBoxLayout()
                 builder_btn = QPushButton(QIcon(":/icons/robot.svg"), "")
-                builder_btn.setToolTip("Open Agents Builder (beta)")
+                builder_btn.setToolTip(trans("agent.builder.tooltip"))
                 builder_btn.clicked.connect(lambda: self.window.tools.get("agent_builder").toggle())
                 node_layout.setContentsMargins(0, 0, 0, 0)
                 node_layout.addLayout(options[key])
@@ -265,6 +267,8 @@ class Preset(BaseConfigDialog):
         widget_base = QWidget()
         widget_base.setLayout(rows)
         widget_base.setMinimumWidth(300)
+        # Keep base column at content height; do not stretch vertically.
+        widget_base.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Maximum)
 
         self.window.ui.nodes['preset.editor.experts'].setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
 
@@ -274,12 +278,16 @@ class Preset(BaseConfigDialog):
 
         widget_main = QWidget()
         widget_main.setLayout(main)
+        # Critical: ensure the whole top pane (base + modes) stays at content height.
+        widget_main.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Maximum)
 
         splitter = QSplitter(Qt.Vertical)
         splitter.addWidget(widget_main)
         splitter.addWidget(widget_prompt)
-        splitter.setStretchFactor(0, 1)
-        splitter.setStretchFactor(1, 2)
+        splitter.setChildrenCollapsible(False)  # avoid accidental collapsing of any pane
+        # All extra vertical space goes to bottom (extra agent options); top stays at its sizeHint.
+        splitter.setStretchFactor(0, 0)
+        splitter.setStretchFactor(1, 1)
         self.window.ui.splitters['editor.presets'] = splitter
 
         widget_personalize = QWidget()
@@ -398,13 +406,17 @@ class AvatarWidget(QWidget):
         main_layout.setContentsMargins(0, 0, 0, 0)
 
         current_avatar_label = QLabel(trans("preset.personalize.avatar.current"))
+        # Center the section title for better visual balance.
+        current_avatar_label.setAlignment(Qt.AlignHCenter)
         main_layout.addWidget(current_avatar_label)
 
         self.avatar_preview = QLabel(self)
         self.avatar_preview.setFixedSize(200, 200)
-        self.avatar_preview.setStyleSheet("border: 1px solid gray;")
+        # Keep a visible border, but round it to visually indicate the circular avatar.
+        self.avatar_preview.setStyleSheet("border: 1px solid gray; border-radius: 100px; background: transparent;")
         self.avatar_preview.setAlignment(Qt.AlignCenter)
-        main_layout.addWidget(self.avatar_preview)
+        # Center the avatar widget within the column.
+        main_layout.addWidget(self.avatar_preview, 0, Qt.AlignHCenter)
 
         buttons_layout = QHBoxLayout()
 
@@ -417,6 +429,8 @@ class AvatarWidget(QWidget):
         self.remove_button.setEnabled(False)
         buttons_layout.addWidget(self.remove_button)
         buttons_layout.setContentsMargins(0, 10, 0, 0)
+        # Center the action buttons below the avatar.
+        buttons_layout.setAlignment(Qt.AlignCenter)
 
         main_layout.addLayout(buttons_layout)
         main_layout.setContentsMargins(0, 10, 0, 0)
@@ -440,7 +454,9 @@ class AvatarWidget(QWidget):
         pixmap = QPixmap(file_path)
         if not pixmap.isNull():
             cover_pix = self.get_cover_pixmap(pixmap, self.avatar_preview.width(), self.avatar_preview.height())
-            self.avatar_preview.setPixmap(cover_pix)
+            # Render the avatar as a circular pixmap.
+            circle_pix = self.get_circular_pixmap(cover_pix, self.avatar_preview.width(), self.avatar_preview.height())
+            self.avatar_preview.setPixmap(circle_pix)
         self.remove_button.setEnabled(True)
 
     def enable_remove_button(self, enabled: bool = True):
@@ -472,7 +488,30 @@ class AvatarWidget(QWidget):
         y = (scaled_pix.height() - target_height) // 2
         return scaled_pix.copy(x, y, target_width, target_height)
 
+    def get_circular_pixmap(self, pixmap, target_width: int, target_height: int):
+        """
+        Create a circular version of the given pixmap using an antialiased clip path.
+
+        :param pixmap: Source pixmap already scaled/cropped to target size
+        :param target_width: Target width
+        :param target_height: Target height
+        :return: Circular masked pixmap with transparent corners
+        """
+        from PySide6.QtGui import QPainter, QPainterPath, QPixmap  # local import to avoid altering global imports
+        result = QPixmap(target_width, target_height)
+        result.fill(Qt.transparent)
+
+        painter = QPainter(result)
+        painter.setRenderHint(QPainter.Antialiasing, True)
+        path = QPainterPath()
+        path.addEllipse(0, 0, target_width, target_height)
+        painter.setClipPath(path)
+        painter.drawPixmap(0, 0, pixmap)
+        painter.end()
+
+        return result
+
     def remove_avatar(self):
         """Remove the current avatar image."""
         self.avatar_preview.clear()
-        self.remove_button.setEnabled(False)
+        self.remove_button.setEnabled(False)