seleniumbase 4.53.3__tar.gz → 4.53.5__tar.gz

{seleniumbase-4.53.3/seleniumbase.egg-info → seleniumbase-4.53.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: seleniumbase
-Version: 4.53.3
+Version: 4.53.5
 Summary: SeleniumBase is a framework for web crawling, scraping, and testing. Supports pytest. CDP Mode adds stealth. Includes many tools.
 Home-page: https://github.com/seleniumbase/SeleniumBase
 Author: Michael Mintz
@@ -71,7 +71,7 @@ Requires-Dist: filelock>=3.32.5
 Requires-Dist: fasteners>=0.20
 Requires-Dist: mycdp>=1.4.0
 Requires-Dist: pynose>=1.5.5
-Requires-Dist: platformdirs>=4.11.5
+Requires-Dist: platformdirs>=4.11.7
 Requires-Dist: typing-extensions>=4.16.0
 Requires-Dist: sbvirtualdisplay>=1.4.0
 Requires-Dist: MarkupSafe>=3.0.3
@@ -155,7 +155,7 @@ Requires-Dist: pyee>=13.0.1; extra == "playwright"
 Provides-Extra: pyautogui
 Requires-Dist: PyAutoGUI>=0.9.54; platform_system != "Linux" and extra == "pyautogui"
 Provides-Extra: uv
-Requires-Dist: uv>=0.12.8; extra == "uv"
+Requires-Dist: uv>=0.12.9; extra == "uv"
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier

{seleniumbase-4.53.3 → seleniumbase-4.53.5}/mcp_servers/server.py

@@ -30,16 +30,10 @@ Tool-selection philosophy:
   elements as structured data.
 - Use check_state for an immediate, non-waiting state check.
 - Use wait_for when the agent needs to wait for a condition to become true.
-- Use assert_that when the agent needs to verify an expected condition and
-  treat failure as an assertion error.
-- Use click/fill_input/select_option/hover/act_on_element for interactions.
-
-Note on elements: CDP-mode element objects (from find_element/find_all) are
-live handles with their own methods (.click(), .get_html(), ...) that can't
-cross the MCP boundary as stateful objects. Tools here resolve elements
-immediately to plain dicts (tag, text, html) rather than returning handles.
-To act on one of several matches, use click(selector, nth=...) rather than
-find + click.
+- Use assert_condition when the agent needs to verify an expected condition
+  and treat failure as an assertion error.
+- Use click/type_text/select_option/hover_with_action/focus_on for
+  interactions and element positioning.
 """
 from __future__ import annotations
 import atexit
@@ -99,7 +93,7 @@ def start_browser(
     """Launch a persistent SeleniumBase Pure CDP Mode browser session.
 
     This must be called before browser interaction tools such as navigate,
-    get_content, click, fill_input, or find_elements. The same browser
+    get_content, click, type_text, or find_elements. The same browser
     session remains active across subsequent MCP tool calls until
     close_browser is called or the server process exits.
 
@@ -283,7 +277,7 @@ def get_page_info() -> dict | str:
         - Need information about matching elements -> use find_elements.
         - Need an immediate state check -> use check_state.
         - Need to wait for a condition -> use wait_for.
-        - Need to verify an expected condition -> use assert_that.
+        - Need to verify an expected condition -> use assert_condition.
 
     Unlike a dedicated browser-status tool, get_page_info is the single
     source of browser/page metadata. If no browser session is active, it
@@ -555,15 +549,26 @@ def get_attributes(
 ) -> Any:
     """Read HTML attributes from a matching element.
 
+    Use this tool when you need the value of one or more HTML attributes
+    such as href, src, value, class, id, name, type, aria-label, or data-*.
+
     Args:
         selector: CSS selector or SeleniumBase text-matching selector for
             the target element.
         attribute: Specific HTML attribute to retrieve. When omitted, return
-            all available attributes as a dictionary.
+            all HTML attributes of the element as a dictionary.
 
     Returns:
         The requested attribute value, or a dictionary containing all
-        attributes when attribute is omitted.
+        HTML attributes of the element when attribute is omitted.
+
+    Tool selection:
+        - Need one or more HTML attribute values from a specific element ->
+          use this tool.
+        - Need to discover multiple matching elements or inspect their text ->
+          use 'find_elements'.
+        - Need visible text or HTML content -> use 'get_content'.
+        - Need to check presence or visibility -> use 'check_state'.
 
     This is a read-only operation and does not modify the element.
     """
@@ -586,7 +591,7 @@ def check_state(
 
     Use this tool when you need an observation of the current state and do
     NOT want to wait for a condition. For waiting behavior, use wait_for.
-    For an expectation that should fail as an assertion, use assert_that.
+    For an expectation that should fail as an assertion, use assert_condition.
 
     Args:
         check:
@@ -608,7 +613,7 @@ def check_state(
         - Immediate yes/no/count observation -> use check_state.
         - Wait until a state becomes true/false -> use wait_for.
         - Verify an expected condition and fail when it is not met ->
-          use assert_that.
+          use assert_condition.
 
     Note:
         Except for count's short lookup, this tool does not wait for elements
@@ -708,114 +713,146 @@ def click(
 
 @mcp.tool()
 @handle_sb_errors
-def hover(
-    selector: str,
-    then_click_selector: str | None = None,
+def hover_with_action(
+    selector1: str,
+    selector2: str | None = None,
+    action: Literal[
+        "none",
+        "click",
+        "drag_and_drop",
+    ] = "none",
 ) -> str:
-    """Hover over an element, optionally clicking an element revealed by hover.
+    """Hover over an element, optionally click another element, or drag-&-drop.
 
-    Use this for menus, dropdowns, tooltips, or other interfaces where an
-    element must first be hovered before its target becomes available.
+    Use this tool for hover interactions, hover-triggered menus, and
+    drag-and-drop operations.
 
     Args:
-        selector: Element to hover over.
-        then_click_selector: Optional element to click after the hover.
-            Useful for a submenu item or dropdown option revealed by hover.
+        selector1:
+            The primary element selector.
 
-    Returns:
-        A confirmation describing the hover/click operation.
-    """
-    sb = _get_sb()
+            For action="none", this is the element to hover over.
 
-    if then_click_selector:
-        sb.hover_and_click(selector, then_click_selector)
-        return f"Hovered {selector} and clicked {then_click_selector}"
+            For action="click", this is the element to hover over before
+            clicking selector2.
 
-    sb.hover_element(selector)
-    return f"Hovered {selector}"
+            For action="drag_and_drop", this is the draggable source element.
 
+        selector2:
+            The secondary element selector.
 
-@mcp.tool()
-@handle_sb_errors
-def drag_and_drop(
-    source_selector: str,
-    target_selector: str,
-) -> str:
-    """Drag a draggable element and drop it onto another element.
+            Required for action="click", where it identifies the element
+            revealed or targeted after hovering selector1.
 
-    Drag-and-drop is performed through SeleniumBase's CDP browser controls,
-    simulating the pointer and mouse events expected by web applications.
+            Required for action="drag_and_drop", where it identifies the
+            destination/drop target.
 
-    Args:
-        source_selector: CSS selector identifying the draggable source.
-        target_selector: CSS selector identifying the drop target.
+            Not used for action="none".
+
+        action:
+            - "none": Hover over selector1 only.
+            - "click": Hover over selector1, then click selector2.
+            - "drag_and_drop": Drag selector1 and drop it onto selector2.
+
+    Returns:
+        A confirmation describing the performed operation.
+
+    Tool selection:
+        - Simple hover -> action="none".
+        - Hover over one element and then click another -> action="click".
+        - Drag one element onto another -> action="drag_and_drop".
+
+    Notes:
+        For action="click", selector1 is the hover target and selector2 is
+        the click target.
 
-    The simulated interaction includes events such as pointerdown,
-    mousedown, dragstart, dragenter, dragover, drop, dragend, mouseup, and
-    pointerup.
+        For action="drag_and_drop", selector1 is the source and selector2
+        is the destination.
     """
-    _get_sb().drag_and_drop(source_selector, target_selector)
-    return f"Dragged {source_selector} onto {target_selector}"
+    sb = _get_sb()
+
+    if action == "none":
+        sb.hover_element(selector1)
+        return f"Hovered {selector1}"
+
+    if action == "click":
+        if selector2 is None:
+            return "Error: action='click' requires selector2."
+        sb.hover_and_click(selector1, selector2)
+        return f"Hovered {selector1} and clicked {selector2}"
+
+    if action == "drag_and_drop":
+        if selector2 is None:
+            return "Error: action='drag_and_drop' requires selector2."
+        sb.drag_and_drop(selector1, selector2)
+        return f"Dragged {selector1} onto {selector2}"
+
+    return (
+        f"Error: unknown action '{action}'. "
+        "Use 'none', 'click', or 'drag_and_drop'."
+    )
 
 
 @mcp.tool()
 @handle_sb_errors
-def fill_input(
+def type_text(
     selector: str,
     text: str = "",
     mode: Literal[
-        "type",
+        "fill_input",
         "append",
-        "set_value",
         "fast_type",
-        "clear",
-    ] = "type",
+        "set_value",
+        "clear_only",
+    ] = "fill_input",
     timeout: int | float | None = 7,
 ) -> str:
-    """Enter, append, directly set, or clear text in a form control.
+    """Fill, append, fast-type, directly set, or clear a form control.
 
     Use this tool for input elements, textareas, and contenteditable elements.
 
     Args:
         selector: CSS selector or SeleniumBase selector identifying the
             input, textarea, or contenteditable element.
-        text: Text to enter or set. Ignored when mode="clear".
+        text: Text to enter or set. Not used when mode="clear_only".
         mode:
-            - "type": Clear the field and type text normally.
-            - "append": Keep the existing value and send text as keystrokes.
+            - "fill_input": Clear the field and then type text normally.
+            - "append": Keep the existing value and add text as keystrokes.
+            - "fast_type": Clear the field and type text without pauses.
             - "set_value": Set the value directly and immediately. This can
               be useful for fast form filling but does not simulate normal
-              key events.
-            - "fast_type": Clear the field and type text quickly.
-            - "clear": Empty the field; text is ignored.
+              key events. It can also be used to handle input sliders,
+              e.g. 'input[type="range"]'.
+            - "clear_only": Empty the text field; text is ignored.
         timeout: Maximum seconds to wait for the target element.
 
     Tool selection:
-        - Normal human-like text entry -> mode="type".
-        - Add text without clearing -> mode="append".
-        - Directly set a value -> mode="set_value".
-        - Fast typing -> mode="fast_type".
-        - Empty a field -> mode="clear".
+        - Normal text entry to replace existing text -> mode="fill_input".
+        - Add text without clearing the field first -> mode="append".
+        - Fast typing to replace existing text -> mode="fast_type".
+        - Directly set a value (e.g. input slider) -> mode="set_value".
+        - Empty a field of all text -> mode="clear_only".
     """
     sb = _get_sb()
 
-    if mode == "type":
+    if mode == "fill_input":
         sb.type(selector, text, timeout=timeout)
     elif mode == "append":
         sb.send_keys(selector, text, timeout=timeout)
-    elif mode == "set_value":
-        sb.set_value(selector, text, timeout=timeout)
     elif mode == "fast_type":
         sb.fast_type(selector, text, timeout=timeout)
-    elif mode == "clear":
+    elif mode == "set_value":
+        sb.set_value(selector, text, timeout=timeout)
+    elif mode == "clear_only":
         sb.clear_input(selector, timeout=timeout)
     else:
         return (
             f"Error: unknown mode '{mode}'. "
-            "Use 'type', 'append', 'set_value', 'fast_type', or 'clear'."
+            "Use 'fill_input', 'append', 'fast_type', "
+            "'set_value', or 'clear_only'."
         )
 
-    return f"fill_input(mode={mode!r}) done for {selector}"
+    return f"type_text(mode={mode!r}) done for {selector}"
 
 
 @mcp.tool()
@@ -860,50 +897,52 @@ def select_option(
 
 @mcp.tool()
 @handle_sb_errors
-def act_on_element(
+def focus_on(
     selector: str,
     action: Literal[
+        "scroll_to_element",
         "focus",
         "highlight",
-        "scroll_into_view",
-    ] = "focus",
+    ] = "scroll_to_element",
 ) -> str:
-    """Perform a non-click positioning or debugging action on an element.
+    """Scroll to, focus, or highlight an element.
 
-    Use this tool when an element needs to be focused, highlighted for human
-    observation/debugging, or scrolled into the viewport.
+    Use this tool when an element needs to be brought into view, focused for
+    keyboard interaction, or highlighted for debugging/demonstration.
 
     This tool does NOT click, type into, select from, hover over, or otherwise
     activate the element.
 
     Args:
         selector: CSS selector or SeleniumBase selector identifying the target.
+
         action:
+            - "scroll_to_element": Scroll the page until the element is in
+              the current viewport. This is the default action.
             - "focus": Move keyboard focus to the element.
             - "highlight": Temporarily highlight the element for debugging or
               demonstration. This can affect timing and may reduce stealth.
-            - "scroll_into_view": Scroll the page until the element is in the
-              current viewport.
 
     Tool selection:
+        - Bring an element into view -> use focus_on with the default action.
+        - Focus an element -> use focus_on(action="focus").
+        - Highlight element for debugging -> use focus_on(action="highlight").
         - Click -> use click.
-        - Type into a form control -> use fill_input.
-        - Hover -> use hover.
-        - Focus, highlight, or scroll without activating -> use
-          act_on_element.
+        - Type text into a text field -> use type_text.
+        - Hover -> use hover_with_action.
     """
     sb = _get_sb()
 
-    if action == "focus":
+    if action == "scroll_to_element":
+        sb.scroll_into_view(selector)
+    elif action == "focus":
         sb.find_element(selector).focus()
     elif action == "highlight":
         sb.highlight(selector)
-    elif action == "scroll_into_view":
-        sb.scroll_into_view(selector)
     else:
         return (
             f"Error: unknown action '{action}'. "
-            "Use 'focus', 'highlight', or 'scroll_into_view'."
+            "Use 'scroll_to_element', 'focus', or 'highlight'."
         )
 
     return f"{action} done for {selector}"
@@ -931,7 +970,7 @@ def wait_for(
     Use this tool when the page is dynamic and an automation step must wait
     for a condition before continuing.
 
-    Unlike check_state, this tool intentionally waits. Unlike assert_that,
+    Unlike check_state, this tool intentionally waits. Unlike assert_condition,
     its purpose is synchronization rather than validating a test expectation.
 
     Args:
@@ -953,7 +992,7 @@ def wait_for(
     Tool selection:
         - Check current state immediately -> use check_state.
         - Wait for a state/content transition -> use wait_for.
-        - Verify an expected value/condition -> use assert_that.
+        - Verify an expected value/condition -> use assert_condition.
     """
     sb = _get_sb()
 
@@ -983,11 +1022,11 @@ def wait_for(
 
 @mcp.tool()
 @handle_sb_errors
-def assert_that(
+def assert_condition(
     check: Literal[
         "element_present",
         "element_visible",
-        "text",
+        "text_visible",
         "title",
         "url",
         "url_contains",
@@ -1000,23 +1039,24 @@ def assert_that(
     """Verify an expected browser condition and fail when it is not met.
 
     Use this tool for explicit verification. Unlike check_state, which simply
-    reports the current state, assert_that treats a failed expectation as an
-    error. Unlike wait_for, URL/title checks do not wait.
+    reports the current state, assert_condition treats a failed expectation
+    as an error. Unlike wait_for, URL/title checks do not wait.
 
     Args:
         check:
             - "element_present": Verify selector identifies a present element.
             - "element_visible": Verify selector identifies a visible element.
-            - "text": Verify expected text within selector, or within the
-              whole HTML document when selector is omitted.
+            - "text_visible": Verify expected text is visible within selector,
+              or within the whole HTML document when selector is omitted.
             - "title": Verify the exact page title.
             - "url": Verify the exact current URL.
             - "url_contains": Verify that the current URL contains expected.
         selector: Element selector for element_present, element_visible, and
-            text checks.
-        expected: Expected text/title/URL value for text, title, url, and
-            url_contains.
-        exact: For check="text", require exact text rather than a substring.
+            text_visible checks.
+        expected: Expected text/title/URL value for text_visible, title, url,
+            and url_contains.
+        exact: For check="text_visible", require exact text
+            rather than a substring.
         timeout: Maximum seconds to wait for element/text checks.
 
     Returns:
@@ -1029,14 +1069,16 @@ def assert_that(
     Tool selection:
         - Just inspect current state -> use check_state.
         - Wait for a condition to become true -> use wait_for.
-        - Verify that an expected condition is true -> use assert_that.
+        - Verify that an expected condition is true -> use assert_condition.
     """
     sb = _get_sb()
 
     if check in ("element_present", "element_visible") and selector is None:
         return f"Error: check='{check}' requires value for `selector`."
 
-    if check in ("text", "title", "url", "url_contains") and expected is None:
+    if check in (
+        "text_visible", "title", "url", "url_contains"
+    ) and expected is None:
         return f"Error: check='{check}' requires value for `expected`."
 
     if check == "element_present":
@@ -1047,13 +1089,13 @@ def assert_that(
         sb.assert_element_visible(selector, timeout=timeout)
         return f"Confirmed {selector} is visible."
 
-    if check == "text":
+    if check == "text_visible":
         target = selector or "html"
         if exact:
             sb.assert_exact_text(expected, target, timeout=timeout)
         else:
             sb.assert_text(expected, target, timeout=timeout)
-        return f"Confirmed text in {target}."
+        return f"Confirmed visible text {expected} in {target}."
 
     if check == "title":
         sb.assert_title(expected)
@@ -1069,7 +1111,8 @@ def assert_that(
 
     return (
         f"Error: unknown check '{check}'. Use 'element_present', "
-        f"'element_visible', 'text', 'title', 'url', or 'url_contains'."
+        "'element_visible', 'text_visible', 'title', 'url', "
+        "or 'url_contains'."
     )
 
 
@@ -1221,8 +1264,8 @@ def scroll(
             up/down scrolling. For example, amount=25 scrolls approximately
             one quarter of the viewport height.
 
-    Use act_on_element(action="scroll_into_view") when the goal is to reveal
-    a specific element rather than scroll the page by a relative amount.
+    Use focus_on(action="scroll_to_element") when the goal is to reveal a
+    specific element rather than scroll the page by a relative amount.
     """
     sb = _get_sb()
 

{seleniumbase-4.53.3 → seleniumbase-4.53.5}/requirements.txt

@@ -11,7 +11,7 @@ filelock>=3.32.5
 fasteners>=0.20
 mycdp>=1.4.0
 pynose>=1.5.5
-platformdirs>=4.11.5
+platformdirs>=4.11.7
 typing-extensions>=4.16.0
 sbvirtualdisplay>=1.4.0
 MarkupSafe>=3.0.3

{seleniumbase-4.53.3 → seleniumbase-4.53.5}/seleniumbase/__version__.py

@@ -1,2 +1,2 @@
 # seleniumbase package
-__version__ = "4.53.3"
+__version__ = "4.53.5"

{seleniumbase-4.53.3 → seleniumbase-4.53.5}/seleniumbase/core/browser_launcher.py

@@ -821,6 +821,7 @@ def uc_open_with_cdp_mode(driver, url=None, **kwargs):
     cdp.remove_from_dom = CDPM.remove_from_dom
     cdp.remove_elements = CDPM.remove_elements
     cdp.send_keys = CDPM.send_keys
+    cdp.fast_keys = CDPM.fast_keys
     cdp.press_keys = CDPM.press_keys
     cdp.type = CDPM.type
     cdp.fast_type = CDPM.fast_type

{seleniumbase-4.53.3 → seleniumbase-4.53.5}/seleniumbase/core/proxy_helper.py

@@ -185,6 +185,9 @@ def validate_proxy_string(proxy_string, keep_scheme=False):
     val_ip = re.match(
         r"^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}:\d+$", proxy_string
     )
+    HOSTNAME_PATTERN = (
+        re.compile(r"^[a-zA-Z0-9]([a-zA-Z0-9\-]{0,61}[a-zA-Z0-9])?$")
+    )
     if not val_ip:
         if proxy_string.startswith("http://"):
             proxy_string = proxy_string.split("http://")[1]
@@ -200,7 +203,10 @@ def validate_proxy_string(proxy_string, keep_scheme=False):
         chunks = proxy_string.split(":")
         if len(chunks) == 2:
             if re.match(r"^\d+$", chunks[1]):
-                if page_utils.is_valid_url("http://" + proxy_string):
+                if (
+                    page_utils.is_valid_url("http://" + proxy_string)
+                    or HOSTNAME_PATTERN.match(chunks[0])
+                ):
                     valid = True
         elif len(chunks) == 3:
             if re.match(r"^\d+$", chunks[2]):

{seleniumbase-4.53.3 → seleniumbase-4.53.5}/seleniumbase/core/sb_cdp.py

@@ -1280,6 +1280,26 @@ class CDPMethods():
         self.__slow_mode_pause_if_set()
         self.loop.run_until_complete(self.page.sleep(0.025))
 
+    def fast_keys(self, selector, text, timeout=None):
+        """Similar to send_keys(), but presses keys at full speed.
+        This method DOES NOT clear the text field before pressing."""
+        if not timeout:
+            timeout = settings.SMALL_TIMEOUT
+        self.__slow_mode_pause_if_set()
+        element = self.select(selector, timeout=timeout)
+        element.scroll_into_view()
+        if text.endswith("\n") or text.endswith("\r"):
+            text = text[:-1] + "\r\n"
+        elif (
+            element.tag_name == "textarea"
+            and "\n" in text
+            and "\r" not in text
+        ):
+            text = text.replace("\n", "\r")
+        element.send_keys(text, fast=True)
+        self.__slow_mode_pause_if_set()
+        self.loop.run_until_complete(self.page.sleep(0.025))
+
     def press_keys(self, selector, text, timeout=None):
         """Similar to send_keys(), but presses keys at human speed."""
         if not timeout:
@@ -1313,7 +1333,8 @@ class CDPMethods():
         self.loop.run_until_complete(self.page.sleep(0.025))
 
     def fast_type(self, selector, text, timeout=None):
-        """Similar to send_keys(), but presses keys really fast.
+        """Similar to type(), but presses keys at full speed.
+        This method clears the text field before typing.
         (Don't use if going for stealth. This is just for speed.)"""
         if not timeout:
             timeout = settings.SMALL_TIMEOUT

{seleniumbase-4.53.3 → seleniumbase-4.53.5/seleniumbase.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: seleniumbase
-Version: 4.53.3
+Version: 4.53.5
 Summary: SeleniumBase is a framework for web crawling, scraping, and testing. Supports pytest. CDP Mode adds stealth. Includes many tools.
 Home-page: https://github.com/seleniumbase/SeleniumBase
 Author: Michael Mintz
@@ -71,7 +71,7 @@ Requires-Dist: filelock>=3.32.5
 Requires-Dist: fasteners>=0.20
 Requires-Dist: mycdp>=1.4.0
 Requires-Dist: pynose>=1.5.5
-Requires-Dist: platformdirs>=4.11.5
+Requires-Dist: platformdirs>=4.11.7
 Requires-Dist: typing-extensions>=4.16.0
 Requires-Dist: sbvirtualdisplay>=1.4.0
 Requires-Dist: MarkupSafe>=3.0.3
@@ -155,7 +155,7 @@ Requires-Dist: pyee>=13.0.1; extra == "playwright"
 Provides-Extra: pyautogui
 Requires-Dist: PyAutoGUI>=0.9.54; platform_system != "Linux" and extra == "pyautogui"
 Provides-Extra: uv
-Requires-Dist: uv>=0.12.8; extra == "uv"
+Requires-Dist: uv>=0.12.9; extra == "uv"
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier

{seleniumbase-4.53.3 → seleniumbase-4.53.5}/seleniumbase.egg-info/requires.txt

@@ -9,7 +9,7 @@ filelock>=3.32.5
 fasteners>=0.20
 mycdp>=1.4.0
 pynose>=1.5.5
-platformdirs>=4.11.5
+platformdirs>=4.11.7
 typing-extensions>=4.16.0
 sbvirtualdisplay>=1.4.0
 MarkupSafe>=3.0.3
@@ -121,4 +121,4 @@ proxy.py==2.4.3
 PyAutoGUI>=0.9.54
 
 [uv]
-uv>=0.12.8
+uv>=0.12.9

{seleniumbase-4.53.3 → seleniumbase-4.53.5}/setup.py

@@ -177,7 +177,7 @@ setup(
         'fasteners>=0.20',
         'mycdp>=1.4.0',
         'pynose>=1.5.5',
-        'platformdirs>=4.11.5',
+        'platformdirs>=4.11.7',
         'typing-extensions>=4.16.0',
         'sbvirtualdisplay>=1.4.0',
         'MarkupSafe>=3.0.3',
@@ -303,7 +303,7 @@ setup(
         # Required for local MCP server debugging with:
         #     mcp dev server.py
         "uv": [
-            "uv>=0.12.8"
+            "uv>=0.12.9"
         ],
     },
     packages=[