refactor: stream, thumbnail method, add player

Author: ankit-v2-3

README.md

@@ -67,7 +67,7 @@ video = conn.upload(url="https://www.youtube.com/")
 video = conn.upload(file_path="path/to/video.mp4")
 
 # get the stream url for the video
-stream_url = video.get_stream()
+stream_url = video.generate_stream()
 
 ```
 
@@ -139,7 +139,7 @@ stream_url = result.compile()
 # get shots of the result returns a list of Shot objects
 shots = result.get_shots()
 # get stream url of the shot
-short_stream_url = shots[0].get_stream()
+short_stream_url = shots[0].generate_stream()
 
 ```
 
@@ -155,10 +155,10 @@ video = collection.get_video("video_id")
 # get the stream url of the dynamically curated video based on the given timeline sequence
 # optional parameters:
 #   - timeline: Optional[list[tuple[int, int]] to specify the start and end time of the video
-stream_url = video.get_stream(timeline=[(0, 10), (30, 40)])
+stream_url = video.generate_stream(timeline=[(0, 10), (30, 40)])
 
-# get thumbnail of the video
-thumbnail = video.get_thumbnail()
+# get thumbnail url of the video
+thumbnail_url = video.generate_thumbnail()
 
 # get transcript of the video
 # optional parameters:

videodb/search.py

@@ -1,3 +1,5 @@
+import webbrowser as web
+
 from abc import ABC, abstractmethod
 from videodb._constants import (
     SearchType,
@@ -15,8 +17,8 @@ class SearchResult:
     def __init__(self, _connection, **kwargs):
         self._connection = _connection
         self.shots = []
-        self.text_summary = None
-        self.stream = None
+        self.stream_url = None
+        self.player_url = None
         self.collection_id = "default"
         self._results = kwargs.get("results", [])
         self._format_results()
@@ -38,18 +40,27 @@ def _format_results(self):
                     )
                 )
 
+    def __repr__(self) -> str:
+        return (
+            f"SearchResult("
+            f"collection_id={self.collection_id}, "
+            f"stream_url={self.stream_url}, "
+            f"player_url={self.player_url}, "
+            f"shots={self.shots})"
+        )
+
     def get_shots(self) -> List[Shot]:
         return self.shots
 
     def compile(self) -> str:
-        """Compile the search result shots into a stream link
+        """Compile the search result shots into a stream url
 
         :raises SearchError: If no shots are found in the search results
-        :return: The stream link
+        :return: The stream url
         :rtype: str
         """
-        if self.stream:
-            return self.stream
+        if self.stream_url:
+            return self.stream_url
         elif self.shots:
             compile_data = self._connection.post(
                 path=f"{ApiPath.compile}",
@@ -62,12 +73,23 @@ def compile(self) -> str:
                     for shot in self.shots
                 ],
             )
-            self.stream = compile_data.get("stream_link")
-            return self.stream
+            self.stream_url = compile_data.get("stream_link")
+            self.player_url = compile_data.get("player_link")
+            return self.stream_url
 
         else:
             raise SearchError("No shots found in search results to compile")
 
+    def play(self) -> str:
+        """Generate a stream url for the shot and open it in the default browser
+
+        :return: The stream url
+        :rtype: str
+        """
+        self.compile()
+        web.open(self.player_url)
+        return self.player_url
+
 
 class Search(ABC):
     """Search interface inside video or collection"""

videodb/shot.py

@@ -1,6 +1,6 @@
 """This module contains the shot class"""
 
-
+import webbrowser as web
 from typing import Optional
 from videodb._constants import (
     ApiPath,
@@ -29,7 +29,8 @@ def __init__(
         self.end = end
         self.text = text
         self.search_score = search_score
-        self.stream = None
+        self.stream_url = None
+        self.player_url = None
 
     def __repr__(self) -> str:
         return (
@@ -40,22 +41,23 @@ def __repr__(self) -> str:
             f"end={self.end}, "
             f"text={self.text}, "
             f"search_score={self.search_score}, "
-            f"stream={self.stream})"
+            f"stream_url={self.stream_url}, "
+            f"player_url={self.player_url})"
         )
 
     def __getitem__(self, key):
         """Get an item from the shot object"""
         return self.__dict__[key]
 
-    def get_stream(self) -> str:
-        """Get the shot into a stream link
+    def generate_stream(self) -> str:
+        """Generate a stream url for the shot
 
-        :return: The stream link
+        :return: The stream url
         :rtype: str
         """
 
-        if self.stream:
-            return self.stream
+        if self.stream_url:
+            return self.stream_url
         else:
             stream_data = self._connection.post(
                 path=f"{ApiPath.video}/{self.video_id}/{ApiPath.stream}",
@@ -64,5 +66,16 @@ def get_stream(self) -> str:
                     "length": self.video_length,
                 },
             )
-            self.stream = stream_data.get("stream_link")
-            return self.stream
+            self.stream_url = stream_data.get("stream_link")
+            self.player_url = stream_data.get("player_link")
+            return self.stream_url
+
+    def play(self) -> str:
+        """Generate a stream url for the shot and open it in the default browser
+
+        :return: The stream url
+        :rtype: str
+        """
+        self.generate_stream()
+        web.open(self.player_url)
+        return self.player_url

videodb/video.py

@@ -1,3 +1,4 @@
+import webbrowser as web
 from videodb._constants import (
     ApiPath,
     SearchType,
@@ -14,10 +15,11 @@ def __init__(self, _connection, id: str, collection_id: str, **kwargs) -> None:
         self._connection = _connection
         self.id = id
         self.collection_id = collection_id
-        self.stream_link = kwargs.get("stream_link", None)
+        self.stream_url = kwargs.get("stream_link", None)
+        self.player_url = kwargs.get("player_link", None)
         self.name = kwargs.get("name", None)
         self.description = kwargs.get("description", None)
-        self.thumbnail = kwargs.get("thumbnail", None)
+        self.thumbnail_url = kwargs.get("thumbnail", None)
         self.length = float(kwargs.get("length", 0.0))
         self.transcript = kwargs.get("transcript", None)
         self.transcript_text = kwargs.get("transcript_text", None)
@@ -27,10 +29,11 @@ def __repr__(self) -> str:
             f"Video("
             f"id={self.id}, "
             f"collection_id={self.collection_id}, "
-            f"stream_link={self.stream_link}, "
+            f"stream_url={self.stream_url}, "
+            f"player_url={self.player_url}, "
             f"name={self.name}, "
             f"description={self.description}, "
-            f"thumbnail={self.thumbnail}, "
+            f"thumbnail_url={self.thumbnail_url}, "
             f"length={self.length})"
         )
 
@@ -63,16 +66,16 @@ def delete(self) -> None:
         """
         self._connection.delete(path=f"{ApiPath.video}/{self.id}")
 
-    def get_stream(self, timeline: Optional[list[tuple[int, int]]] = None) -> str:
-        """Get the stream link of the video
+    def generate_stream(self, timeline: Optional[list[tuple[int, int]]] = None) -> str:
+        """Generate the stream url of the video
 
         :param list timeline: The timeline of the video to be streamed. Defaults to None.
         :raises InvalidRequestError: If the get_stream fails
-        :return: The stream link of the video
+        :return: The stream url of the video
         :rtype: str
         """
-        if not timeline and self.stream_link:
-            return self.stream_link
+        if not timeline and self.stream_url:
+            return self.stream_url
 
         stream_data = self._connection.post(
             path=f"{ApiPath.video}/{self.id}/{ApiPath.stream}",
@@ -81,16 +84,18 @@ def get_stream(self, timeline: Optional[list[tuple[int, int]]] = None) -> str:
                 "length": self.length,
             },
         )
-        return stream_data.get("stream_link")
+        self.stream_url = stream_data.get("stream_link")
+        self.player_url = stream_data.get("player_link")
+        return self.stream_url
 
-    def get_thumbnail(self):
-        if self.thumbnail:
-            return self.thumbnail
+    def generate_thumbnail(self):
+        if self.thumbnail_url:
+            return self.thumbnail_url
         thumbnail_data = self._connection.get(
             path=f"{ApiPath.video}/{self.id}/{ApiPath.thumbnail}"
         )
-        self.thumbnail = thumbnail_data.get("thumbnail")
-        return self.thumbnail
+        self.thumbnail_url = thumbnail_data.get("thumbnail")
+        return self.thumbnail_url
 
     def _fetch_transcript(self, force: bool = False) -> None:
         if self.transcript and not force:
@@ -132,15 +137,17 @@ def add_subtitle(self) -> str:
                 "type": Workflows.add_subtitles,
             },
         )
-        return subtitle_data.get("stream_link")
+        self.stream_url = subtitle_data.get("stream_link")
+        self.player_url = subtitle_data.get("player_link")
+        return self.stream_url
 
     def insert_video(self, video, timestamp: float) -> str:
         """Insert a video into another video
 
         :param Video video: The video to be inserted
         :param float timestamp: The timestamp where the video should be inserted
         :raises InvalidRequestError: If the insert fails
-        :return: The stream link of the inserted video
+        :return: The stream url of the inserted video
         :rtype: str
         """
         if timestamp > float(self.length):
@@ -171,5 +178,16 @@ def insert_video(self, video, timestamp: float) -> str:
                 for shot in all_shots
             ],
         )
-        stream_link = compile_data.get("stream_link")
-        return stream_link
+        self.stream_url = compile_data.get("stream_link")
+        self.player_url = compile_data.get("player_link")
+        return self.stream_url
+
+    def play(self) -> str:
+        """Generate a stream url for the shot and open it in the default browser
+
+        :return: The stream url
+        :rtype: str
+        """
+        self.generate_stream()
+        web.open(self.player_url)
+        return self.player_url