lockbot 2.5.2__tar.gz → 2.5.3__tar.gz

{lockbot-2.5.2/python/lockbot.egg-info → lockbot-2.5.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lockbot
-Version: 2.5.2
+Version: 2.5.3
 Summary: Cluster resource management bot for IM platforms
 Author-email: Jianbang Yang <yangjianbang112@gmail.com>
 License: MIT

{lockbot-2.5.2 → lockbot-2.5.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "lockbot"
-version = "2.5.2"
+version = "2.5.3"
 description = "Cluster resource management bot for IM platforms"
 readme = "README.md"
 license = {text = "MIT"}

{lockbot-2.5.2 → lockbot-2.5.3}/python/lockbot/backend/app/bots/router.py

@@ -312,9 +312,6 @@ def update_bot(
     if user.role != "super_admin" and bot.user_id != user.id:
         raise HTTPException(status_code=403, detail="Cannot edit another user's bot")
 
-    if bot.status == "running":
-        raise HTTPException(status_code=409, detail="Cannot update a running bot. Stop it first.")
-
     changes = {}
     if body.name is not None:
         # Check for duplicate name (excluding current bot and deleted bots)
@@ -958,6 +955,7 @@ def get_bot_logs(
     limit: int = 50,
     level: str | None = None,
     category: str | None = None,
+    since: str | None = None,
     user: User = Depends(get_current_user),
     db: Session = Depends(get_db),
 ):
@@ -985,6 +983,8 @@ def get_bot_logs(
         entries = [e for e in entries if e.get("level", "").upper() == level_upper]
     if category:
         entries = [e for e in entries if e.get("category") == category]
+    if since:
+        entries = [e for e in entries if e.get("created_at", "") > since]
 
     # Sort newest first, paginate
     entries.sort(key=lambda e: e.get("created_at", ""), reverse=True)

{lockbot-2.5.2 → lockbot-2.5.3}/python/lockbot/backend/app/bots/schemas.py

@@ -33,6 +33,12 @@ def _validate_config_overrides(v: dict | None) -> dict | None:
             lo, hi = bounds  # type: ignore[misc]
             if not (lo <= val <= hi):
                 errors.append(f"{key} must be between {lo} and {hi}")
+
+    max_dur = v.get("MAX_LOCK_DURATION")
+    default_dur = v.get("DEFAULT_DURATION")
+    if isinstance(max_dur, int) and isinstance(default_dur, int) and max_dur != -1 and default_dur > max_dur:
+        errors.append("DEFAULT_DURATION must not exceed MAX_LOCK_DURATION")
+
     if errors:
         raise ValueError("; ".join(errors))
     return v

{lockbot-2.5.2 → lockbot-2.5.3}/python/lockbot/core/base_bot.py

@@ -26,7 +26,12 @@ class BotState:
     _loader = None  # Subclasses or instances must set this
 
     def __init__(self, config=None):
-        self.bot_state = self._loader(config=config)
+        result = self._loader(config=config)
+        if isinstance(result, tuple):
+            self.bot_state, self.clamped_user_ids = result
+        else:
+            self.bot_state = result
+            self.clamped_user_ids = set()
 
 
 class BaseLockBot:
@@ -70,6 +75,22 @@ class BaseLockBot:
         # scheduler can recalculate its next wakeup without waiting for idle.
         self._on_state_changed: Callable[[], None] | None = None
 
+        self._notify_clamped_users()
+
+    def _notify_clamped_users(self):
+        """Send notification to users whose locks were shortened by max_duration reduction."""
+        clamped = getattr(self.state, "clamped_user_ids", set())
+        if not clamped:
+            return
+        max_dur = self.config.get_val("MAX_LOCK_DURATION")
+        dur_str = format_duration(max_dur, config=self.config)
+        msg = t("notify.duration_clamped", config=self.config, max_duration=dur_str)
+        reply = self.adapter.build_reply(msg, list(clamped))
+        try:
+            self.adapter.send(reply)
+        except Exception:
+            self.logger.warning("Failed to notify clamped users: %s", clamped)
+
     def _notify_state_changed(self) -> None:
         """Call _on_state_changed if wired up (no-op otherwise)."""
         if self._on_state_changed is not None:

{lockbot-2.5.2 → lockbot-2.5.3}/python/lockbot/core/device_bot.py

@@ -193,6 +193,25 @@ class DeviceBot(BaseLockBot):
                         user_id, self._msg_with_usage("error.device_in_use_or_shared", node_key=node_key)
                     )
 
+                if max_dur > 0:
+                    for device in devices:
+                        total_duration = duration
+                        user_info = find_user_info(device["current_users"], user_id)
+                        if user_info:
+                            total_duration += user_info["duration"]
+                            start_time = user_info["start_time"]
+                        else:
+                            start_time = timestamp
+                        if remaining_duration(start_time, total_duration) > max_dur:
+                            return self.show_error(
+                                user_id,
+                                t(
+                                    "error.lock_max_duration_exceeded",
+                                    config=self.config,
+                                    max_duration=format_duration(max_dur, config=self.config),
+                                ),
+                            )
+
             for node_key, dev_ids in zip(node_key_list, dev_ids_list, strict=True):
                 node_status = self.state.bot_state[node_key]
                 devices = [node_status[dev_id] for dev_id in dev_ids]
@@ -207,16 +226,6 @@ class DeviceBot(BaseLockBot):
                     else:
                         total_duration += user_info["duration"]
 
-                    if max_dur > 0 and remaining_duration(user_info["start_time"], total_duration) > max_dur:
-                        return self.show_error(
-                            user_id,
-                            t(
-                                "error.lock_max_duration_exceeded",
-                                config=self.config,
-                                max_duration=format_duration(max_dur, config=self.config),
-                            ),
-                        )
-
                     user_info["duration"] = total_duration
                     user_info["is_notified"] = False
                     device["current_users"] = [user_info]
@@ -251,6 +260,25 @@ class DeviceBot(BaseLockBot):
                         user_id, self._msg_with_usage("error.device_exclusive_mode", node_key=node_key)
                     )
 
+                if max_dur > 0:
+                    for device in devices:
+                        user_info = find_user_info(device["current_users"], user_id)
+                        if user_info:
+                            total_duration = user_info["duration"] + duration
+                            start_time = user_info["start_time"]
+                        else:
+                            total_duration = duration
+                            start_time = timestamp
+                        if remaining_duration(start_time, total_duration) > max_dur:
+                            return self.show_error(
+                                user_id,
+                                t(
+                                    "error.slock_max_duration_exceeded",
+                                    config=self.config,
+                                    max_duration=format_duration(max_dur, config=self.config),
+                                ),
+                            )
+
             for node_key, dev_ids in zip(node_key_list, dev_ids_list, strict=True):
                 node_status = self.state.bot_state[node_key]
                 devices = [node_status[dev_id] for dev_id in dev_ids]
@@ -260,29 +288,8 @@ class DeviceBot(BaseLockBot):
                     user_info = find_user_info(device["current_users"], user_id)
                     if not user_info:
                         user_info = create_user_info(user_id, duration, timestamp, config=self.config)
-                        if max_dur > 0 and remaining_duration(user_info["start_time"], user_info["duration"]) > max_dur:
-                            return self.show_error(
-                                user_id,
-                                t(
-                                    "error.slock_max_duration_exceeded",
-                                    config=self.config,
-                                    max_duration=format_duration(max_dur, config=self.config),
-                                ),
-                            )
                         device["current_users"].append(user_info)
                     else:
-                        if (
-                            max_dur > 0
-                            and remaining_duration(user_info["start_time"], user_info["duration"] + duration) > max_dur
-                        ):
-                            return self.show_error(
-                                user_id,
-                                t(
-                                    "error.slock_max_duration_exceeded",
-                                    config=self.config,
-                                    max_duration=format_duration(max_dur, config=self.config),
-                                ),
-                            )
                         user_info["duration"] += duration
                         user_info["is_notified"] = False
 

{lockbot-2.5.2 → lockbot-2.5.3}/python/lockbot/core/i18n/en.py

@@ -138,6 +138,11 @@ MESSAGES = {
     "notify.resource_available_header": "📢 Resource available\nResource is idle, please lock within {timeout}:\n\n",
     "notify.booking_expired_header": "⚠️ The following bookings have expired:\n",
     "notify.pending_bookings_header": "🗓️ Pending bookings:\n",
+    "notify.duration_clamped": (
+        "⚠️ [Lock Duration Adjusted]\n"
+        "The admin has set max lock duration to {max_duration}. "
+        "Your remaining lock time has been automatically shortened.\n"
+    ),
     # ── Help: news (inline) ──
     "help.news_header": "📢 Announcement:\n",
     # ── Help: project links ──

{lockbot-2.5.2 → lockbot-2.5.3}/python/lockbot/core/i18n/zh.py

@@ -132,6 +132,9 @@ MESSAGES = {
     "notify.resource_available_header": "📢【资源可用提醒】\n资源已空闲，请在 {timeout} 内lock:\n\n",
     "notify.booking_expired_header": "⚠️ 以下预约已失效，请重新预约：\n",
     "notify.pending_bookings_header": "🗓️ 目前待抢锁的预约：\n",
+    "notify.duration_clamped": (
+        "⚠️【锁定时长调整通知】\n管理员已将最大锁定时长调整为 {max_duration}，您的锁定剩余时长已被自动缩短，请知悉。\n"
+    ),
     # ── Help: news (inline) ──
     "help.news_header": "📢 公告:\n",
     # ── Help: project links ──

{lockbot-2.5.2 → lockbot-2.5.3}/python/lockbot/core/io.py

@@ -106,7 +106,11 @@ def log_to_file(user_id, command, node_key, dev_ids="", duration="", config=None
 
 
 def create_or_load_device_state(config=None):
-    """Create or load device cluster state, applying max-duration limits."""
+    """Create or load device cluster state, applying max-duration limits.
+
+    Returns (state_dict, clamped_user_ids) where clamped_user_ids is a set of
+    user IDs whose lock durations were shortened by max_duration enforcement.
+    """
     state_filename = os.path.join(_bot_dir(config), "bot_state.json")
     cluster_configs = _cfg_get(config, "CLUSTER_CONFIGS")
     max_duration = _cfg_get(config, "MAX_LOCK_DURATION", -1)
@@ -126,11 +130,13 @@ def create_or_load_device_state(config=None):
 
     _migrate_old_state_file(state_filename, config)
 
+    clamped_user_ids = set()
+
     if os.path.exists(state_filename):
         loaded_state = _load_state_from_file(state_filename)
 
         if not loaded_state:
-            return default_state
+            return default_state, clamped_user_ids
 
         for node_key, node_status in loaded_state.items():
             if node_key not in cluster_configs:
@@ -144,20 +150,28 @@ def create_or_load_device_state(config=None):
                     device_status = old_by_id[dev_id]
                     _migrate_status_fields(device_status)
                     _migrate_user_info_fields(device_status["current_users"])
-                    apply_max_duration_limit(device_status["current_users"], max_duration)
+                    clamped = apply_max_duration_limit(device_status["current_users"], max_duration)
+                    clamped_user_ids.update(clamped)
                     default_device.update(**device_status)
 
-        return default_state
+        if clamped_user_ids:
+            save_bot_state_to_file(default_state, config)
+
+        return default_state, clamped_user_ids
 
     else:
-        return default_state
+        return default_state, clamped_user_ids
 
 
 # ── Node state ─────────────────────────────────────────────────
 
 
 def create_or_load_node_state(config=None):
-    """Create or load node state, applying max-duration limits."""
+    """Create or load node state, applying max-duration limits.
+
+    Returns (state_dict, clamped_user_ids) where clamped_user_ids is a set of
+    user IDs whose lock durations were shortened by max_duration enforcement.
+    """
     state_filename = os.path.join(_bot_dir(config), "bot_state.json")
     cluster_configs = _cfg_get(config, "CLUSTER_CONFIGS")
     max_duration = _cfg_get(config, "MAX_LOCK_DURATION", -1)
@@ -173,11 +187,13 @@ def create_or_load_node_state(config=None):
 
     _migrate_old_state_file(state_filename, config)
 
+    clamped_user_ids = set()
+
     if os.path.exists(state_filename):
         loaded_state = _load_state_from_file(state_filename)
 
         if not loaded_state:
-            return default_state
+            return default_state, clamped_user_ids
 
         for node_key, node_status in loaded_state.items():
             if node_key not in default_state:
@@ -186,13 +202,17 @@ def create_or_load_node_state(config=None):
             node_status.pop("fullname", None)
             _migrate_user_info_fields(node_status.get("current_users", []))
             _migrate_user_info_fields(node_status.get("booking_list", []))
-            apply_max_duration_limit(node_status.get("current_users", []), max_duration)
+            clamped = apply_max_duration_limit(node_status.get("current_users", []), max_duration)
+            clamped_user_ids.update(clamped)
             default_state[node_key].update(**node_status)
 
-        return default_state
+        if clamped_user_ids:
+            save_bot_state_to_file(default_state, config)
+
+        return default_state, clamped_user_ids
 
     else:
-        return default_state
+        return default_state, clamped_user_ids
 
 
 # ── State persistence ──────────────────────────────────────────

{lockbot-2.5.2 → lockbot-2.5.3}/python/lockbot/core/node_bot.py

@@ -121,6 +121,26 @@ class NodeBot(BaseLockBot):
                 return self.show_error(user_id, self._msg_with_usage("error.node_in_use_or_shared"))
 
             timestamp = int(time.time())
+
+            if max_dur > 0:
+                for node in nodes:
+                    total_duration = duration
+                    user_info = find_user_info(node["current_users"], user_id)
+                    if user_info:
+                        total_duration += user_info["duration"]
+                        start_time = user_info["start_time"]
+                    else:
+                        start_time = timestamp
+                    if remaining_duration(start_time, total_duration) > max_dur:
+                        return self.show_error(
+                            user_id,
+                            t(
+                                "error.lock_max_duration_exceeded",
+                                config=self.config,
+                                max_duration=format_duration(max_dur, config=self.config),
+                            ),
+                        )
+
             for node in nodes:
                 node["status"] = "exclusive"
 
@@ -131,16 +151,6 @@ class NodeBot(BaseLockBot):
                 else:
                     total_duration += user_info["duration"]
 
-                if max_dur > 0 and remaining_duration(user_info["start_time"], total_duration) > max_dur:
-                    return self.show_error(
-                        user_id,
-                        t(
-                            "error.lock_max_duration_exceeded",
-                            config=self.config,
-                            max_duration=format_duration(max_dur, config=self.config),
-                        ),
-                    )
-
                 user_info["duration"] = total_duration
                 user_info["is_notified"] = False
                 node["current_users"] = [user_info]
@@ -165,30 +175,31 @@ class NodeBot(BaseLockBot):
                 return self.show_error(user_id, self._msg_with_usage("error.node_exclusive_mode"))
 
             timestamp = int(time.time())
-            for node in nodes:
-                node["status"] = "shared"
-                user_info = find_user_info(node["current_users"], user_id)
-                if not user_info:
-                    user_info = create_user_info(user_id, duration, timestamp, config=self.config)
-                    if max_dur > 0 and remaining_duration(user_info["start_time"], user_info["duration"]) > max_dur:
+
+            if max_dur > 0:
+                for node in nodes:
+                    user_info = find_user_info(node["current_users"], user_id)
+                    if user_info:
+                        total_duration = user_info["duration"] + duration
+                        start_time = user_info["start_time"]
+                    else:
+                        total_duration = duration
+                        start_time = timestamp
+                    if remaining_duration(start_time, total_duration) > max_dur:
                         msg = t(
                             "error.slock_max_duration_exceeded",
                             config=self.config,
                             max_duration=format_duration(max_dur, config=self.config),
                         )
                         return self.show_error(user_id, msg)
+
+            for node in nodes:
+                node["status"] = "shared"
+                user_info = find_user_info(node["current_users"], user_id)
+                if not user_info:
+                    user_info = create_user_info(user_id, duration, timestamp, config=self.config)
                     node["current_users"].append(user_info)
                 else:
-                    if (
-                        max_dur > 0
-                        and remaining_duration(user_info["start_time"], user_info["duration"] + duration) > max_dur
-                    ):
-                        msg = t(
-                            "error.slock_max_duration_exceeded",
-                            config=self.config,
-                            max_duration=format_duration(max_dur, config=self.config),
-                        )
-                        return self.show_error(user_id, msg)
                     user_info["duration"] += duration
                     user_info["is_notified"] = False
 

{lockbot-2.5.2 → lockbot-2.5.3}/python/lockbot/core/queue_bot.py

@@ -60,6 +60,30 @@ class QueueBot(NodeBot):
             timestamp = int(time.time())
             users_to_notify = set()
             users_to_notify.add(user_id)
+
+            if max_dur > 0:
+                for node in nodes:
+                    booking_info = find_user_info(node["booking_list"], user_id)
+                    if not command_has_duration and booking_info:
+                        check_duration = booking_info["duration"]
+                    else:
+                        check_duration = duration
+                    user_info = find_user_info(node["current_users"], user_id)
+                    if user_info:
+                        check_duration += user_info["duration"]
+                        start_time = user_info["start_time"]
+                    else:
+                        start_time = timestamp
+                    if remaining_duration(start_time, check_duration) > max_dur:
+                        return self.show_error(
+                            user_id,
+                            t(
+                                "error.lock_max_duration_exceeded",
+                                config=self.config,
+                                max_duration=format_duration(max_dur, config=self.config),
+                            ),
+                        )
+
             for node in nodes:
                 node["status"] = "exclusive"
                 booking_info = find_user_info(node["booking_list"], user_id)
@@ -82,16 +106,6 @@ class QueueBot(NodeBot):
                     for booking_user in node["booking_list"]:
                         users_to_notify.add(booking_user["user_id"])
 
-                if max_dur > 0 and remaining_duration(user_info["start_time"], total_duration) > max_dur:
-                    return self.show_error(
-                        user_id,
-                        t(
-                            "error.lock_max_duration_exceeded",
-                            config=self.config,
-                            max_duration=format_duration(max_dur, config=self.config),
-                        ),
-                    )
-
                 user_info["duration"] = total_duration
                 user_info["is_notified"] = False
                 node["current_users"] = [user_info]
@@ -125,19 +139,19 @@ class QueueBot(NodeBot):
                 return self.show_error(user_id, self._msg_with_usage("error.already_locked", sep="\n"))
 
             timestamp = int(time.time())
-            for node in nodes:
-                user_info = create_user_info(user_id, duration, timestamp, config=self.config)
 
-                if max_dur > 0 and duration > max_dur:
-                    return self.show_error(
-                        user_id,
-                        t(
-                            "error.lock_max_duration_exceeded",
-                            config=self.config,
-                            max_duration=format_duration(max_dur, config=self.config),
-                        ),
-                    )
+            if max_dur > 0 and duration > max_dur:
+                return self.show_error(
+                    user_id,
+                    t(
+                        "error.lock_max_duration_exceeded",
+                        config=self.config,
+                        max_duration=format_duration(max_dur, config=self.config),
+                    ),
+                )
 
+            for node in nodes:
+                user_info = create_user_info(user_id, duration, timestamp, config=self.config)
                 node["booking_list"].append(user_info)
 
             reply = self.adapter.build_reply(self._msg_with_usage("success.booking_added"), [user_id])
@@ -165,6 +179,17 @@ class QueueBot(NodeBot):
             users_to_notify = set()
             users_to_notify.add(user_id)
             nodes = [self.state.bot_state[node_key] for node_key in node_keys]
+
+            if max_dur > 0 and remaining_duration(timestamp, duration) > max_dur:
+                return self.show_error(
+                    user_id,
+                    t(
+                        "error.lock_max_duration_exceeded",
+                        config=self.config,
+                        max_duration=format_duration(max_dur, config=self.config),
+                    ),
+                )
+
             for node in nodes:
                 node["status"] = "exclusive"
                 remove_user_info(node["booking_list"], user_id)
@@ -189,15 +214,6 @@ class QueueBot(NodeBot):
                 for user in node["booking_list"]:
                     user["is_notified"] = False
                     users_to_notify.add(user["user_id"])
-                if max_dur > 0 and remaining_duration(user_info["start_time"], total_duration) > max_dur:
-                    return self.show_error(
-                        user_id,
-                        t(
-                            "error.lock_max_duration_exceeded",
-                            config=self.config,
-                            max_duration=format_duration(max_dur, config=self.config),
-                        ),
-                    )
 
                 user_info["duration"] = total_duration
                 user_info["is_notified"] = False

{lockbot-2.5.2 → lockbot-2.5.3}/python/lockbot/core/utils.py

@@ -72,11 +72,17 @@ def remaining_duration(start_time, duration):
 
 
 def apply_max_duration_limit(user_list, max_duration):
-    """Clamp each user's remaining duration to max_duration in place."""
+    """Clamp each user's remaining duration to max_duration in place.
+
+    Returns a list of user_ids whose durations were clamped.
+    """
+    clamped_users = []
     for user_info in user_list:
         final_duration = remaining_duration(user_info["start_time"], user_info["duration"])
         if max_duration > 0 and final_duration > max_duration:
             user_info["duration"] = user_info["duration"] - final_duration + max_duration
+            clamped_users.append(user_info["user_id"])
+    return clamped_users
 
 
 def format_access_mode(status: str, config=None) -> str:

{lockbot-2.5.2 → lockbot-2.5.3/python/lockbot.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lockbot
-Version: 2.5.2
+Version: 2.5.3
 Summary: Cluster resource management bot for IM platforms
 Author-email: Jianbang Yang <yangjianbang112@gmail.com>
 License: MIT