Handle comments

Author: AutomatedTester

py/generate_bidi.py

@@ -591,16 +591,12 @@ def generate_code(self, enhancements: dict[str, Any] | None = None) -> str:
         # Collect needed imports to avoid duplicates
         needs_command_builder = bool(self.commands)
         needs_dataclass = self.commands or self.types or self.events
-        needs_threading = self.events
         needs_callable = self.events
-        needs_session = self.events
 
         stdlib_imports = []
         local_imports = []
 
         # Add imports (field import will be added conditionally after code generation)
-        if needs_threading:
-            stdlib_imports.append("import threading")
         if needs_callable:
             stdlib_imports.append("from collections.abc import Callable")
         if needs_dataclass:
@@ -611,9 +607,9 @@ def generate_code(self, enhancements: dict[str, Any] | None = None) -> str:
             local_imports.append(
                 "from selenium.webdriver.common.bidi.common import command_builder"
             )
-        if needs_session:
+        if self.events:
             local_imports.append(
-                "from selenium.webdriver.common.bidi.session import Session"
+                "from selenium.webdriver.common.bidi._event_manager import EventConfig, _EventWrapper, _EventManager"
             )
 
         code += "\n".join(stdlib_imports) + "\n"
@@ -797,165 +793,11 @@ def generate_code(self, enhancements: dict[str, Any] | None = None) -> str:
 """
             code += "\n\n"
 
-        # Generate EventConfig and _EventManager for modules with events
-        if self.events:
-            # Generate EventConfig dataclass
-            code += """@dataclass
-class EventConfig:
-    \"\"\"Configuration for a BiDi event.\"\"\"
-    event_key: str
-    bidi_event: str
-    event_class: type
-
-
-"""
-
-            # Generate _EventManager class
-            code += """class _EventWrapper:
-    \"\"\"Wrapper to provide event_class attribute for WebSocketConnection callbacks.\"\"\"
-    def __init__(self, bidi_event: str, event_class: type):
-        self.event_class = bidi_event  # WebSocket expects the BiDi event name as event_class
-        self._python_class = event_class  # Keep reference to Python dataclass for deserialization
-
-    def from_json(self, params: dict) -> Any:
-        \"\"\"Deserialize event params into the wrapped Python dataclass.
-
-        Args:
-            params: Raw BiDi event params with camelCase keys.
-
-        Returns:
-            An instance of the dataclass, or the raw dict on failure.
-        \"\"\"
-        if self._python_class is None or self._python_class is dict:
-            return params
-        try:
-            # Delegate to a classmethod from_json if the class defines one
-            if hasattr(self._python_class, \"from_json\") and callable(
-                self._python_class.from_json
-            ):
-                return self._python_class.from_json(params)
-            import dataclasses as dc
-
-            snake_params = {self._camel_to_snake(k): v for k, v in params.items()}
-            if dc.is_dataclass(self._python_class):
-                valid_fields = {f.name for f in dc.fields(self._python_class)}
-                filtered = {k: v for k, v in snake_params.items() if k in valid_fields}
-                return self._python_class(**filtered)
-            return self._python_class(**snake_params)
-        except Exception:
-            return params
-
-    @staticmethod
-    def _camel_to_snake(name: str) -> str:
-        result = [name[0].lower()]
-        for char in name[1:]:
-            if char.isupper():
-                result.extend([\"_\", char.lower()])
-            else:
-                result.append(char)
-        return \"\".join(result)
-
-
-class _EventManager:
-    \"\"\"Manages event subscriptions and callbacks.\"\"\"
-
-    def __init__(self, conn, event_configs: dict[str, EventConfig]):
-        self.conn = conn
-        self.event_configs = event_configs
-        self.subscriptions: dict = {}
-        self._event_wrappers = {}  # Cache of _EventWrapper objects
-        self._bidi_to_class = {config.bidi_event: config.event_class for config in event_configs.values()}
-        self._available_events = ", ".join(sorted(event_configs.keys()))
-        self._subscription_lock = threading.Lock()
-
-        # Create event wrappers for each event
-        for config in event_configs.values():
-            wrapper = _EventWrapper(config.bidi_event, config.event_class)
-            self._event_wrappers[config.bidi_event] = wrapper
-
-    def validate_event(self, event: str) -> EventConfig:
-        event_config = self.event_configs.get(event)
-        if not event_config:
-            raise ValueError(f"Event '{event}' not found. Available events: {self._available_events}")
-        return event_config
-
-    def subscribe_to_event(self, bidi_event: str, contexts: list[str] | None = None) -> None:
-        \"\"\"Subscribe to a BiDi event if not already subscribed.\"\"\"
-        with self._subscription_lock:
-            if bidi_event not in self.subscriptions:
-                session = Session(self.conn)
-                result = session.subscribe([bidi_event], contexts=contexts)
-                sub_id = (
-                    result.get(\"subscription\") if isinstance(result, dict) else None
-                )
-                self.subscriptions[bidi_event] = {
-                    \"callbacks\": [],
-                    \"subscription_id\": sub_id,
-                }
-
-    def unsubscribe_from_event(self, bidi_event: str) -> None:
-        \"\"\"Unsubscribe from a BiDi event if no more callbacks exist.\"\"\"
-        with self._subscription_lock:
-            entry = self.subscriptions.get(bidi_event)
-            if entry is not None and not entry[\"callbacks\"]:
-                session = Session(self.conn)
-                sub_id = entry.get(\"subscription_id\")
-                if sub_id:
-                    session.unsubscribe(subscriptions=[sub_id])
-                else:
-                    session.unsubscribe(events=[bidi_event])
-                del self.subscriptions[bidi_event]
-
-    def add_callback_to_tracking(self, bidi_event: str, callback_id: int) -> None:
-        with self._subscription_lock:
-            self.subscriptions[bidi_event][\"callbacks\"].append(callback_id)
-
-    def remove_callback_from_tracking(self, bidi_event: str, callback_id: int) -> None:
-        with self._subscription_lock:
-            entry = self.subscriptions.get(bidi_event)
-            if entry and callback_id in entry[\"callbacks\"]:
-                entry[\"callbacks\"].remove(callback_id)
-
-    def add_event_handler(self, event: str, callback: Callable, contexts: list[str] | None = None) -> int:
-        event_config = self.validate_event(event)
-        # Use the event wrapper for add_callback
-        event_wrapper = self._event_wrappers.get(event_config.bidi_event)
-        callback_id = self.conn.add_callback(event_wrapper, callback)
-        self.subscribe_to_event(event_config.bidi_event, contexts)
-        self.add_callback_to_tracking(event_config.bidi_event, callback_id)
-        return callback_id
-
-    def remove_event_handler(self, event: str, callback_id: int) -> None:
-        event_config = self.validate_event(event)
-        event_wrapper = self._event_wrappers.get(event_config.bidi_event)
-        self.conn.remove_callback(event_wrapper, callback_id)
-        self.remove_callback_from_tracking(event_config.bidi_event, callback_id)
-        self.unsubscribe_from_event(event_config.bidi_event)
-
-    def clear_event_handlers(self) -> None:
-        \"\"\"Clear all event handlers.\"\"\"
-        with self._subscription_lock:
-            if not self.subscriptions:
-                return
-            session = Session(self.conn)
-            for bidi_event, entry in list(self.subscriptions.items()):
-                event_wrapper = self._event_wrappers.get(bidi_event)
-                callbacks = entry[\"callbacks\"] if isinstance(entry, dict) else entry
-                if event_wrapper:
-                    for callback_id in callbacks:
-                        self.conn.remove_callback(event_wrapper, callback_id)
-                sub_id = (
-                    entry.get(\"subscription_id\") if isinstance(entry, dict) else None
-                )
-                if sub_id:
-                    session.unsubscribe(subscriptions=[sub_id])
-                else:
-                    session.unsubscribe(events=[bidi_event])
-            self.subscriptions.clear()
-
-
-"""
-            code += "\n\n"
+        # EventConfig, _EventWrapper, and _EventManager are imported from
+        # selenium.webdriver.common.bidi._event_manager (see import section above)
+        # rather than being duplicated inline in every generated module.
+        if False:  # placeholder to preserve indentation structure
+            pass
 
         # Generate class
         # Convert module name (camelCase or snake_case) to proper class name (PascalCase)

py/private/bidi_enhancements_manifest.py

@@ -86,7 +86,7 @@
         # convenience NORMAL constant.  In the BiDi spec "normal" is the state
         # represented by ClientWindowRectState, but exposing it here keeps the
         # Python API consistent with the old ClientWindowState enum.
-        "exclude_types": ["ClientWindowNamedState"],
+        "exclude_types": ["ClientWindowNamedState", "SetClientWindowStateParameters"],
         "extra_dataclasses": [
             '''class ClientWindowNamedState:
     """Named states for a browser client window."""
@@ -95,6 +95,18 @@
     MAXIMIZED = "maximized"
     MINIMIZED = "minimized"
     NORMAL = "normal"''',
+            '''@dataclass
+class SetClientWindowStateParameters:
+    """SetClientWindowStateParameters.
+
+    The ``state`` field is required and must be either a named-state string
+    (e.g. ``ClientWindowNamedState.MAXIMIZED``) or a
+    :class:`ClientWindowRectState` instance.  ``client_window`` is the ID of
+    the window to affect.
+    """
+
+    client_window: Any | None = None
+    state: Any | None = None''',
         ],
         # Override the generator-produced set_download_behavior so that
         # downloadBehavior is never stripped by the generic None filter.
@@ -1141,7 +1153,11 @@ def __init__(self, type: Any | None, value: Any | None) -> None:
         self.value = value
 
     def to_bidi_dict(self) -> dict:
-        return {"type": self.type, "value": self.value}''',
+        return {"type": self.type, "value": self.value}
+
+    def to_dict(self) -> dict:
+        """Backward-compatible alias for to_bidi_dict()."""
+        return self.to_bidi_dict()''',
             '''class SameSite:
     """SameSite cookie attribute values."""
 
@@ -1219,7 +1235,11 @@ def to_bidi_dict(self) -> dict:
             result["sameSite"] = self.same_site
         if self.expiry is not None:
             result["expiry"] = self.expiry
-        return result''',
+        return result
+
+    def to_dict(self) -> dict:
+        """Backward-compatible alias for to_bidi_dict()."""
+        return self.to_bidi_dict()''',
             # Custom PartialCookie with camelCase serialization
             '''@dataclass
 class PartialCookie:
@@ -1253,7 +1273,11 @@ def to_bidi_dict(self) -> dict:
             result["sameSite"] = self.same_site
         if self.expiry is not None:
             result["expiry"] = self.expiry
-        return result''',
+        return result
+
+    def to_dict(self) -> dict:
+        """Backward-compatible alias for to_bidi_dict()."""
+        return self.to_bidi_dict()''',
             # BrowsingContextPartitionDescriptor: first positional arg is *context*
             # (the auto-generated dataclass had `type` first, breaking positional
             # usage like BrowsingContextPartitionDescriptor(driver.current_window_handle))
@@ -1270,7 +1294,12 @@ def __init__(self, context: Any = None, type: str = "context") -> None:
         self.type = type
 
     def to_bidi_dict(self) -> dict:
-        return {"type": "context", "context": self.context}''',
+        return {"type": "context", "context": self.context}
+
+    def to_dict(self) -> dict:
+        """Backward-compatible alias for to_bidi_dict()."""
+        return self.to_bidi_dict()''',
+
             # StorageKeyPartitionDescriptor with camelCase serialization
             '''@dataclass
 class StorageKeyPartitionDescriptor:
@@ -1287,7 +1316,11 @@ def to_bidi_dict(self) -> dict:
             result["userContext"] = self.user_context
         if self.source_origin is not None:
             result["sourceOrigin"] = self.source_origin
-        return result''',
+        return result
+
+    def to_dict(self) -> dict:
+        """Backward-compatible alias for to_bidi_dict()."""
+        return self.to_bidi_dict()''',
         ],
         # Override the generated Storage class methods (Python's last-definition-
         # wins semantics means these extra_methods shadow the generated ones).
@@ -1335,7 +1368,19 @@ def to_bidi_dict(self) -> dict:
         params = {k: v for k, v in params.items() if v is not None}
         cmd = command_builder("storage.setCookie", params)
         result = self._conn.execute(cmd)
+        if isinstance(result, dict):
+            pk_raw = result.get("partitionKey")
+            pk = (
+                PartitionKey(
+                    user_context=pk_raw.get("userContext"),
+                    source_origin=pk_raw.get("sourceOrigin"),
+                )
+                if isinstance(pk_raw, dict)
+                else None
+            )
+            return SetCookieResult(partition_key=pk)
         return result''',
+
             '''    def delete_cookies(self, filter=None, partition=None):
         """Execute storage.deleteCookies."""
         if filter and hasattr(filter, "to_bidi_dict"):
@@ -1349,6 +1394,17 @@ def to_bidi_dict(self) -> dict:
         params = {k: v for k, v in params.items() if v is not None}
         cmd = command_builder("storage.deleteCookies", params)
         result = self._conn.execute(cmd)
+        if isinstance(result, dict):
+            pk_raw = result.get("partitionKey")
+            pk = (
+                PartitionKey(
+                    user_context=pk_raw.get("userContext"),
+                    source_origin=pk_raw.get("sourceOrigin"),
+                )
+                if isinstance(pk_raw, dict)
+                else None
+            )
+            return DeleteCookiesResult(partition_key=pk)
         return result''',
         ],
     },
@@ -1383,7 +1439,11 @@ def to_bidi_dict(self) -> dict:
             result["file"] = self.file
         if self.prompt is not None:
             result["prompt"] = self.prompt
-        return result''',
+        return result
+
+    def to_dict(self) -> dict:
+        """Backward-compatible alias for to_bidi_dict()."""
+        return self.to_bidi_dict()''',
         ],
     },
 

py/selenium/webdriver/common/bidi/browser.py

@@ -139,13 +139,6 @@ class RemoveUserContextParameters:
     user_context: Any | None = None
 
 
-@dataclass
-class SetClientWindowStateParameters:
-    """SetClientWindowStateParameters."""
-
-    client_window: Any | None = None
-
-
 @dataclass
 class ClientWindowRectState:
     """ClientWindowRectState."""
@@ -188,6 +181,19 @@ class ClientWindowNamedState:
     MINIMIZED = "minimized"
     NORMAL = "normal"
 
+@dataclass
+class SetClientWindowStateParameters:
+    """SetClientWindowStateParameters.
+
+    The ``state`` field is required and must be either a named-state string
+    (e.g. ``ClientWindowNamedState.MAXIMIZED``) or a
+    :class:`ClientWindowRectState` instance.  ``client_window`` is the ID of
+    the window to affect.
+    """
+
+    client_window: Any | None = None
+    state: Any | None = None
+
 class Browser:
     """WebDriver BiDi browser module."""