Merge branch 'main' into ankit/add-rtstream

Author: ankit-v2-3

.github/workflows/trigger-agent-toolkit-update.yaml

@@ -0,0 +1,19 @@
+name: Trigger Agent Toolkit Update
+
+on:
+  pull_request:
+    types: [closed]
+
+jobs:
+  trigger-videodb-helper-update:
+    if: ${{ github.event.pull_request.merged && github.event.pull_request.base.ref == 'main' }}
+    runs-on: ubuntu-latest
+    steps:
+      - name: Trigger Agent Toolkit Update workflow via repository_dispatch
+        run: |
+          curl -X POST -H "Accept: application/vnd.github+json" \
+               -H "Authorization: Bearer ${{ secrets.AGENT_TOOLKIT_TOKEN }}" \
+               -H "X-GitHub-Api-Version: 2022-11-28" \
+               https://api.github.com/repos/video-db/agent-toolkit/dispatches \
+               -d '{"event_type": "sdk-context-update", "client_payload": {"pr_number": ${{ github.event.pull_request.number }}}}'
+               

videodb/_constants.py

@@ -1,4 +1,5 @@
 """Constants used in the videodb package."""
+
 from typing import Union
 from dataclasses import dataclass
 
@@ -74,6 +75,11 @@ class ApiPath:
     status = "status"
     event = "event"
     alert = "alert"
+    generate_url = "generate_url"
+    generate = "generate"
+    web = "web"
+    translate = "translate"
+    dub = "dub"
 
 
 class Status:

videodb/audio.py

@@ -4,7 +4,17 @@
 
 
 class Audio:
-    def __init__(self, _connection, id: str, collection_id: str, **kwargs) -> None:
+    """Audio class to interact with the Audio
+
+    :ivar str id: Unique identifier for the audio
+    :ivar str collection_id: ID of the collection this audio belongs to
+    :ivar str name: Name of the audio file
+    :ivar float length: Duration of the audio in seconds
+    """
+
+    def __init__(
+        self, _connection, id: str, collection_id: str, **kwargs
+    ) -> None:
         self._connection = _connection
         self.id = id
         self.collection_id = collection_id
@@ -20,5 +30,24 @@ def __repr__(self) -> str:
             f"length={self.length})"
         )
 
+    def generate_url(self) -> str:
+        """Generate the signed url of the audio.
+
+        :raises InvalidRequestError: If the get_url fails
+        :return: The signed url of the audio
+        :rtype: str
+        """
+        url_data = self._connection.post(
+            path=f"{ApiPath.audio}/{self.id}/{ApiPath.generate_url}",
+            params={"collection_id": self.collection_id},
+        )
+        return url_data.get("signed_url", None)
+
     def delete(self) -> None:
+        """Delete the audio.
+
+        :raises InvalidRequestError: If the delete fails
+        :return: None if the delete is successful
+        :rtype: None
+        """
         self._connection.delete(f"{ApiPath.audio}/{self.id}")

videodb/client.py

@@ -24,40 +24,77 @@
 
 
 class Connection(HttpClient):
-    def __init__(self, api_key: str, base_url: str) -> None:
+    """Connection class to interact with the VideoDB"""
+
+    def __init__(self, api_key: str, base_url: str) -> "Connection":
+        """Initializes a new instance of the Connection class with specified API credentials.
+
+        Note: Users should not initialize this class directly.
+        Instead use :meth:`videodb.connect() <videodb.connect>`
+
+        :param str api_key: API key for authentication
+        :param str base_url: Base URL of the VideoDB API
+        :raise ValueError: If the API key is not provided
+        :return: :class:`Connection <Connection>` object, to interact with the VideoDB
+        :rtype: :class:`videodb.client.Connection`
+        """
         self.api_key = api_key
         self.base_url = base_url
         self.collection_id = "default"
         super().__init__(api_key=api_key, base_url=base_url, version=__version__)
 
     def get_collection(self, collection_id: Optional[str] = "default") -> Collection:
+        """Get a collection object by its ID.
+
+        :param str collection_id: ID of the collection (optional, default: "default")
+        :return: :class:`Collection <Collection>` object
+        :rtype: :class:`videodb.collection.Collection`
+        """
         collection_data = self.get(path=f"{ApiPath.collection}/{collection_id}")
         self.collection_id = collection_data.get("id", "default")
         return Collection(
             self,
             self.collection_id,
             collection_data.get("name"),
             collection_data.get("description"),
+            collection_data.get("is_public", False),
         )
 
     def get_collections(self) -> List[Collection]:
+        """Get a list of all collections.
+
+        :return: List of :class:`Collection <Collection>` objects
+        :rtype: list[:class:`videodb.collection.Collection`]
+        """
         collections_data = self.get(path=ApiPath.collection)
         return [
             Collection(
                 self,
                 collection.get("id"),
                 collection.get("name"),
                 collection.get("description"),
+                collection.get("is_public", False),
             )
             for collection in collections_data.get("collections")
         ]
 
-    def create_collection(self, name: str, description: str) -> Collection:
+    def create_collection(
+        self, name: str, description: str, is_public: bool = False
+    ) -> Collection:
+        """Create a new collection.
+
+        :param str name: Name of the collection
+        :param str description: Description of the collection
+        :param bool is_public: Make collection public (optional, default: False)
+        :return: :class:`Collection <Collection>` object
+        :rtype: :class:`videodb.collection.Collection`
+        """
         collection_data = self.post(
             path=ApiPath.collection,
             data={
                 "name": name,
                 "description": description,
+                "is_public": is_public,
             },
         )
         self.collection_id = collection_data.get("id", "default")
@@ -66,9 +103,18 @@ def create_collection(self, name: str, description: str) -> Collection:
             collection_data.get("id"),
             collection_data.get("name"),
             collection_data.get("description"),
+            collection_data.get("is_public", False),
         )
 
     def update_collection(self, id: str, name: str, description: str) -> Collection:
+        """Update an existing collection.
+
+        :param str id: ID of the collection
+        :param str name: Name of the collection
+        :param str description: Description of the collection
+        :return: :class:`Collection <Collection>` object
+        :rtype: :class:`videodb.collection.Collection`
+        """
         collection_data = self.patch(
             path=f"{ApiPath.collection}/{id}",
             data={
@@ -82,12 +128,23 @@ def update_collection(self, id: str, name: str, description: str) -> Collection:
             collection_data.get("id"),
             collection_data.get("name"),
             collection_data.get("description"),
+            collection_data.get("is_public", False),
         )
 
     def check_usage(self) -> dict:
+        """Check the usage.
+
+        :return: Usage data
+        :rtype: dict
+        """
         return self.get(path=f"{ApiPath.billing}/{ApiPath.usage}")
 
     def get_invoices(self) -> List[dict]:
+        """Get a list of all invoices.
+
+        :return: List of invoices
+        :rtype: list[dict]
+        """
         return self.get(path=f"{ApiPath.billing}/{ApiPath.invoices}")
 
     def create_event(self, event_prompt: str, label: str):
@@ -103,6 +160,13 @@ def list_events(self):
         return event_data.get("events", [])
 
     def download(self, stream_link: str, name: str) -> dict:
+        """Download a file from a stream link.
+
+        :param stream_link: URL of the stream to download
+        :param name: Name to save the downloaded file as
+        :return: Download response data
+        :rtype: dict
+        """
         return self.post(
             path=f"{ApiPath.download}",
             data={
@@ -111,6 +175,31 @@ def download(self, stream_link: str, name: str) -> dict:
             },
         )
 
+    def youtube_search(
+        self,
+        query: str,
+        result_threshold: Optional[int] = 10,
+        duration: str = "medium",
+    ) -> List[dict]:
+        """Search for a query on YouTube.
+
+        :param str query: Query to search for
+        :param int result_threshold: Number of results to return (optional)
+        :param str duration: Duration of the video (optional)
+        :return: List of YouTube search results
+        :rtype: List[dict]
+        """
+        search_data = self.post(
+            path=f"{ApiPath.collection}/{self.collection_id}/{ApiPath.search}/{ApiPath.web}",
+            data={
+                "query": query,
+                "result_threshold": result_threshold,
+                "platform": "youtube",
+                "duration": duration,
+            },
+        )
+        return search_data.get("results")
+
     def upload(
         self,
         file_path: str = None,
@@ -120,6 +209,17 @@ def upload(
         description: Optional[str] = None,
         callback_url: Optional[str] = None,
     ) -> Union[Video, Audio, Image, None]:
+        """Upload a file.
+
+        :param str file_path: Path to the file to upload (optional)
+        :param str url: URL of the file to upload (optional)
+        :param MediaType media_type: MediaType object (optional)
+        :param str name: Name of the file (optional)
+        :param str description: Description of the file (optional)
+        :param str callback_url: URL to receive the callback (optional)
+        :return: :class:`Video <Video>`, or :class:`Audio <Audio>`, or :class:`Image <Image>` object
+        :rtype: Union[ :class:`videodb.video.Video`, :class:`videodb.audio.Audio`, :class:`videodb.image.Image`]
+        """
         upload_data = upload(
             self,
             file_path,