video

Author: Skn0tt

playwright/_impl/_page.py

@@ -181,6 +181,9 @@ def __init__(
         self._video: Optional[Video] = None
         self._screencast: Screencast = Screencast(self)
         self._opener = cast("Page", from_nullable_channel(initializer.get("opener")))
+        self._video = Video(
+            self, self._connection, from_nullable_channel(initializer.get("video"))
+        )
         self._close_reason: Optional[str] = None
         self._close_was_called = False
         self._har_routers: List[HarRouter] = []
@@ -228,7 +231,6 @@ def __init__(
                 self._on_web_socket_route(from_channel(params["webSocketRoute"]))
             ),
         )
-        self._channel.on("video", lambda params: self._on_video(params))
         self._channel.on("viewportSizeChanged", self._on_viewport_size_changed)
         self._channel.on(
             "webSocket",
@@ -360,10 +362,6 @@ def _on_download(self, params: Any) -> None:
             Page.Events.Download, Download(self, url, suggested_filename, artifact)
         )
 
-    def _on_video(self, params: Any) -> None:
-        artifact = from_channel(params["artifact"])
-        self._force_video()._artifact_ready(artifact)
-
     def _on_viewport_size_changed(self, params: Any) -> None:
         self._viewport_size = params["viewportSize"]
 
@@ -1196,11 +1194,6 @@ async def pdf(
             await async_writefile(path, decoded_binary)
         return decoded_binary
 
-    def _force_video(self) -> Video:
-        if not self._video:
-            self._video = Video(self)
-        return self._video
-
     @property
     def video(
         self,
@@ -1210,7 +1203,7 @@ def video(
         # too late during launchPersistentContext.
         if not self._browser_context._videos_dir:
             return None
-        return self._force_video()
+        return self._video
 
     @property
     def screencast(self) -> Screencast:

playwright/_impl/_video.py

@@ -19,53 +19,37 @@
 from playwright._impl._helper import Error
 
 if TYPE_CHECKING:  # pragma: no cover
+    from playwright._impl._connection import Connection
     from playwright._impl._page import Page
 
 
 class Video:
-    def __init__(self, page: "Page") -> None:
+    def __init__(
+        self, page: "Page", connection: "Connection", artifact: Artifact = None
+    ) -> None:
         self._loop = page._loop
         self._dispatcher_fiber = page._dispatcher_fiber
         self._page = page
-        self._artifact_future = page._loop.create_future()
-        if page.is_closed():
-            self._page_closed()
-        else:
-            page.on("close", lambda page: self._page_closed())
+        self._artifact = artifact
+        self._is_remote = connection.is_remote
 
     def __repr__(self) -> str:
         return f"<Video page={self._page}>"
 
-    def _page_closed(self) -> None:
-        if not self._artifact_future.done():
-            self._artifact_future.set_exception(Error("Page closed"))
-
-    def _artifact_ready(self, artifact: Artifact) -> None:
-        if not self._artifact_future.done():
-            self._artifact_future.set_result(artifact)
-
     async def path(self) -> pathlib.Path:
-        if self._page._connection.is_remote:
+        if self._is_remote:
             raise Error(
                 "Path is not available when using browserType.connect(). Use save_as() to save a local copy."
             )
-        artifact = await self._artifact_future
-        if not artifact:
-            raise Error("Page did not produce any video frames")
-        return artifact.absolute_path
+        if not self._artifact:
+            raise Error("Video recording has not been started.")
+        return pathlib.Path(self._artifact.absolute_path)
 
     async def save_as(self, path: Union[str, pathlib.Path]) -> None:
-        if self._page._connection._is_sync and not self._page._is_closed:
-            raise Error(
-                "Page is not yet closed. Close the page prior to calling save_as"
-            )
-        artifact = await self._artifact_future
-        if not artifact:
-            raise Error("Page did not produce any video frames")
-        await artifact.save_as(path)
+        if not self._artifact:
+            raise Error("Video recording has not been started.")
+        await self._artifact.save_as(path)
 
     async def delete(self) -> None:
-        artifact = await self._artifact_future
-        if not artifact:
-            raise Error("Page did not produce any video frames")
-        await artifact.delete()
+        if self._artifact:
+            await self._artifact.delete()