MindsDB 1.3.1__py3-none-any.whl → 24.12.4.0__py3-none-any.whl

mindsdb/integrations/handlers/xata_handler/__init__.py

@@ -0,0 +1,29 @@
+from mindsdb.integrations.libs.const import HANDLER_TYPE
+
+from .__about__ import __description__ as description
+from .__about__ import __version__ as version
+from .connection_args import connection_args, connection_args_example
+try:
+    from .xata_handler import XataHandler as Handler
+    import_error = None
+except Exception as e:
+    Handler = None
+    import_error = e
+
+title = "Xata"
+name = "xata"
+type = HANDLER_TYPE.DATA
+icon_path = "icon.svg"
+
+__all__ = [
+    "Handler",
+    "version",
+    "name",
+    "type",
+    "title",
+    "description",
+    "connection_args",
+    "connection_args_example",
+    "import_error",
+    "icon_path",
+]

mindsdb/integrations/handlers/xata_handler/connection_args.py

@@ -0,0 +1,35 @@
+from collections import OrderedDict
+
+from mindsdb.integrations.libs.const import HANDLER_CONNECTION_ARG_TYPE as ARG_TYPE
+
+
+connection_args = OrderedDict(
+    db_url={
+        "type": ARG_TYPE.STR,
+        "description": "Xata database url with region, database and, optionally the branch information",
+        "required": True,
+    },
+    api_key={
+        "type": ARG_TYPE.STR,
+        "description": "personal Xata API key",
+        "required": True,
+        "secret": True
+    },
+    dimension={
+        "type": ARG_TYPE.INT,
+        "description": "default dimension of embeddings vector used to create table when using create (default=8)",
+        "required": False,
+    },
+    similarity_function={
+        "type": ARG_TYPE.STR,
+        "description": "similarity function to use for vector searches (default=cosineSimilarity)",
+        "required": False,
+    }
+)
+
+connection_args_example = OrderedDict(
+    db_url="https://...",
+    api_key="abc_def...",
+    dimension=8,
+    similarity_function="l1"
+)

mindsdb/integrations/handlers/xata_handler/icon.svg

@@ -0,0 +1,29 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="40" height="40" viewBox="0 0 40 40" fill="none">
+  <g clip-path="url(#clip0_155_2527)">
+    <path d="M39.774 10.3803C39.7694 14.2969 38.2073 18.0512 35.4314 20.8174L35.431 20.8171L25.5834 30.6302C25.2422 30.9703 24.6878 30.9712 24.368 30.6109C21.9738 27.913 20.6434 24.4237 20.6476 20.7984C20.6522 16.8819 22.2143 13.1275 24.9902 10.3613L24.9905 10.3616L33.9876 1.39615C34.7985 0.588048 36.1254 0.582252 36.8132 1.4973C38.7274 4.04425 39.7778 7.15861 39.774 10.3803Z" fill="url(#paint0_linear_155_2527)"/>
+    <path d="M4.54255 20.8771C1.76663 18.1109 0.204549 14.3566 0.199961 10.44C0.196188 7.21831 1.24652 4.10395 3.16077 1.55699C3.84851 0.641942 5.17539 0.647742 5.98635 1.45584L14.9835 10.4214L14.9838 10.4211C17.7597 13.1873 19.3218 16.9417 19.3264 20.8583C19.3306 24.4835 18.0001 27.9728 15.6059 30.6707C15.2862 31.031 14.7318 31.0301 14.3906 30.6901L4.54283 20.8769L4.54255 20.8771Z" fill="url(#paint1_linear_155_2527)"/>
+    <path d="M35.0607 38.4363C34.3373 39.3237 33.014 39.3159 32.2048 38.5058L26.6475 32.9421C26.3065 32.6007 26.3072 32.0474 26.649 31.7068L35.8789 22.5092C36.2201 22.1692 36.7767 22.1672 37.0777 22.5433C38.6796 24.545 39.3095 27.3115 38.8333 30.3573C38.3974 33.1451 37.0642 35.9791 35.0607 38.4363Z" fill="url(#paint2_linear_155_2527)"/>
+    <path d="M7.76933 38.5656C6.96017 39.3758 5.63685 39.3835 4.91337 38.4962C2.90995 36.039 1.57672 33.2049 1.14085 30.4171C0.664641 27.3713 1.29454 24.6048 2.89648 22.6031C3.19747 22.227 3.75396 22.229 4.09517 22.569L13.3252 31.7666C13.6669 32.1072 13.6676 32.6605 13.3266 33.0019L7.76933 38.5656Z" fill="url(#paint3_linear_155_2527)"/>
+  </g>
+  <defs>
+    <linearGradient id="paint0_linear_155_2527" x1="19.987" y1="0.800048" x2="19.987" y2="31.2808" gradientUnits="userSpaceOnUse">
+      <stop stop-color="#9F87FF"/>
+      <stop offset="1" stop-color="#8566FF"/>
+    </linearGradient>
+    <linearGradient id="paint1_linear_155_2527" x1="19.987" y1="0.799946" x2="19.987" y2="31.2807" gradientUnits="userSpaceOnUse">
+      <stop stop-color="#9F87FF"/>
+      <stop offset="1" stop-color="#8566FF"/>
+    </linearGradient>
+    <linearGradient id="paint2_linear_155_2527" x1="19.9869" y1="21.8964" x2="19.9869" y2="39.1373" gradientUnits="userSpaceOnUse">
+      <stop stop-color="#DE99F6"/>
+      <stop offset="1" stop-color="#D669FC"/>
+    </linearGradient>
+    <linearGradient id="paint3_linear_155_2527" x1="19.9871" y1="21.8964" x2="19.9871" y2="39.1373" gradientUnits="userSpaceOnUse">
+      <stop stop-color="#DE99F6"/>
+      <stop offset="1" stop-color="#D669FC"/>
+    </linearGradient>
+    <clipPath id="clip0_155_2527">
+      <rect width="40" height="40" fill="white"/>
+    </clipPath>
+  </defs>
+</svg>

mindsdb/integrations/handlers/xata_handler/requirements.txt

@@ -0,0 +1 @@
+xata

mindsdb/integrations/handlers/xata_handler/xata_handler.py

@@ -0,0 +1,347 @@
+from typing import List, Optional
+
+import pandas as pd
+import json
+import xata
+from xata.helpers import BulkProcessor
+
+from mindsdb.integrations.libs.response import RESPONSE_TYPE
+from mindsdb.integrations.libs.response import HandlerResponse
+from mindsdb.integrations.libs.response import HandlerResponse as Response
+from mindsdb.integrations.libs.response import HandlerStatusResponse as StatusResponse
+from mindsdb.integrations.libs.vectordatabase_handler import (
+    FilterCondition,
+    FilterOperator,
+    TableField,
+    VectorStoreHandler,
+)
+from mindsdb.utilities import log
+
+logger = log.getLogger(__name__)
+
+
+class XataHandler(VectorStoreHandler):
+    """This handler handles connection and execution of the Xata statements."""
+
+    name = "xata"
+
+    def __init__(self, name: str, **kwargs):
+        super().__init__(name)
+        self._connection_data = kwargs.get("connection_data")
+        self._client_config = {
+            "db_url": self._connection_data.get("db_url"),
+            "api_key": self._connection_data.get("api_key"),
+        }
+        self._create_table_params = {
+            "dimension": self._connection_data.get("dimension", 8),
+        }
+        self._select_params = {
+            "similarity_function": self._connection_data.get("similarity_function", "cosineSimilarity"),
+        }
+        self._client = None
+        self.is_connected = False
+        self.connect()
+
+    def __del__(self):
+        if self.is_connected is True:
+            self.disconnect()
+
+    def connect(self):
+        """Connect to a Xata database."""
+        if self.is_connected is True:
+            return self._client
+        try:
+            self._client = xata.XataClient(**self._client_config)
+            self.is_connected = True
+            return self._client
+        except Exception as e:
+            logger.error(f"Error connecting to Xata client: {e}!")
+            self.is_connected = False
+
+    def disconnect(self):
+        """Close the database connection."""
+        if self.is_connected is False:
+            return
+        self._client = None
+        self.is_connected = False
+
+    def check_connection(self):
+        """Check the connection to the Xata database."""
+        response_code = StatusResponse(False)
+        need_to_close = self.is_connected is False
+        # NOTE: no direct way to test this
+        # try getting the user, if it fails, it means that we are not connected
+        try:
+            resp = self._client.users().get()
+            if not resp.is_success():
+                raise Exception(resp["message"])
+            response_code.success = True
+        except Exception as e:
+            logger.error(f"Error connecting to Xata: {e}!")
+            response_code.error_message = str(e)
+        finally:
+            if response_code.success is True and need_to_close:
+                self.disconnect()
+            if response_code.success is False and self.is_connected is True:
+                self.is_connected = False
+        return response_code
+
+    def create_table(self, table_name: str, if_not_exists=True) -> HandlerResponse:
+        """Create a table with the given name in the Xata database."""
+
+        resp = self._client.table().create(table_name)
+        if not resp.is_success():
+            raise Exception(f"Unable to create table {table_name}: {resp['message']}")
+        resp = self._client.table().set_schema(
+            table_name=table_name,
+            payload={
+                "columns": [
+                    {
+                        "name": "embeddings",
+                        "type": "vector",
+                        "vector": {"dimension": self._create_table_params["dimension"]}
+                    },
+                    {"name": "content", "type": "text"},
+                    {"name": "metadata", "type": "json"},
+                ]
+            }
+        )
+        if not resp.is_success():
+            raise Exception(f"Unable to change schema of table {table_name}: {resp['message']}")
+
+    def drop_table(self, table_name: str, if_exists=True) -> HandlerResponse:
+        """Delete a table from the Xata database."""
+
+        resp = self._client.table().delete(table_name)
+        if not resp.is_success():
+            raise Exception(f"Unable to delete table: {resp['message']}")
+
+    def get_columns(self, table_name: str) -> HandlerResponse:
+        """Get columns of the given table"""
+        # Vector stores have predefined columns
+        try:
+            # But at least try to see if the table is valid
+            resp = self._client.table().get_columns(table_name)
+            if not resp.is_success():
+                raise Exception(f"Error getting columns: {resp['message']}")
+        except Exception as e:
+            return Response(
+                resp_type=RESPONSE_TYPE.ERROR,
+                error_message=f"{e}",
+            )
+        return super().get_columns(table_name)
+
+    def get_tables(self) -> HandlerResponse:
+        """Get the list of tables in the Xata database."""
+        try:
+            table_names = pd.DataFrame(
+                columns=["TABLE_NAME"],
+                data=[table_data["name"] for table_data in self._client.branch().get_details()["schema"]["tables"]],
+            )
+            return Response(resp_type=RESPONSE_TYPE.TABLE, data_frame=table_names)
+        except Exception as e:
+            return Response(
+                resp_type=RESPONSE_TYPE.ERROR,
+                error_message=f"Error getting list of tables: {e}",
+            )
+
+    def insert(self, table_name: str, data: pd.DataFrame, columns: List[str] = None):
+        """ Insert data into the Xata database. """
+        if columns:
+            data = data[columns]
+        # Convert to records
+        data = data.to_dict("records")
+        # Convert metadata to json
+        for row in data:
+            if "metadata" in row:
+                row["metadata"] = json.dumps(row["metadata"])
+        if len(data) > 1:
+            # Bulk processing
+            bp = BulkProcessor(self._client, throw_exception=True)
+            bp.put_records(table_name, data)
+            bp.flush_queue()
+
+        elif len(data) == 0:
+            # Skip
+            return Response(resp_type=RESPONSE_TYPE.OK)
+        elif "id" in data[0] and TableField.ID.value in columns:
+            # If id present
+            id = data[0]["id"]
+            rest_of_data = data[0].copy()
+            del rest_of_data["id"]
+
+            resp = self._client.records().insert_with_id(
+                table_name=table_name,
+                record_id=id,
+                payload=rest_of_data,
+                create_only=True,
+                columns=columns
+            )
+            if not resp.is_success():
+                raise Exception(resp["message"])
+
+        else:
+            # If id not present
+            resp = self._client.records().insert(
+                table_name=table_name,
+                payload=data[0],
+                columns=columns
+            )
+            if not resp.is_success():
+                raise Exception(resp["message"])
+
+    def update(self, table_name: str, data: pd.DataFrame, columns: List[str] = None) -> HandlerResponse:
+        """Update data in the Xata database."""
+        # Not supported
+        return super().update(table_name, data, columns)
+
+    def _get_xata_operator(self, operator: FilterOperator) -> str:
+        """Translate SQL operator to oprator understood by Xata filter language."""
+        mapping = {
+            FilterOperator.EQUAL: "$is",
+            FilterOperator.NOT_EQUAL: "$isNot",
+            FilterOperator.LESS_THAN: "$lt",
+            FilterOperator.LESS_THAN_OR_EQUAL: "$le",
+            FilterOperator.GREATER_THAN: "$gt",
+            FilterOperator.GREATER_THAN_OR_EQUAL: "$gte",
+            FilterOperator.LIKE: "$pattern",
+        }
+        if operator not in mapping:
+            raise Exception(f"Operator '{operator}' is not supported!")
+        return mapping[operator]
+
+    def _translate_non_vector_conditions(self, conditions: List[FilterCondition]) -> Optional[dict]:
+        """
+        Translate a list of FilterCondition objects a dict that can be used by Xata for filtering.
+        E.g.,
+        [
+            FilterCondition(
+                column="metadata.price",
+                op=FilterOperator.LESS_THAN,
+                value=100,
+            ),
+            FilterCondition(
+                column="metadata.price",
+                op=FilterOperator.GREATER_THAN,
+                value=10,
+            )
+        ]
+        -->
+        {
+            "metadata->price" {
+                "$gt": 10,
+                "$lt": 100
+            },
+        }
+        """
+        if not conditions:
+            return None
+        # Translate metadata columns
+        for condition in conditions:
+            if condition.column.startswith(TableField.METADATA.value):
+                condition.column = condition.column.replace(".", "->")
+        # Generate filters
+        filters = {}
+        for condition in conditions:
+            # Skip search vector condition
+            if condition.column == TableField.SEARCH_VECTOR.value:
+                continue
+            current_filter = original_filter = {}
+            # Special case LIKE: needs pattern translation
+            if condition.op == FilterOperator.LIKE:
+                condition.value = condition.value.replace("%", "*").replace("_", "?")
+            # Generate substatment
+            current_filter[condition.column] = {self._get_xata_operator(condition.op): condition.value}
+            # Check for conflicting and insert
+            for key in original_filter:
+                if key in filters:
+                    filters[key] = {**filters[key], **original_filter[key]}
+                else:
+                    filters = {**filters, **original_filter}
+        return filters if filters else None
+
+    def select(self, table_name: str, columns: List[str] = None, conditions: List[FilterCondition] = None,
+               offset: int = None, limit: int = None) -> pd.DataFrame:
+        """Run general query or a vector similarity search and return results."""
+        if not columns:
+            columns = [col["name"] for col in self.SCHEMA]
+        # Generate filter conditions
+        filters = self._translate_non_vector_conditions(conditions)
+        # Check for search vector
+        search_vector = (
+            []
+            if conditions is None
+            else [
+                condition.value
+                for condition in conditions
+                if condition.column == TableField.SEARCH_VECTOR.value
+            ]
+        )
+        if len(search_vector) > 0:
+            search_vector = search_vector[0]
+        else:
+            search_vector = None
+        # Search
+        results_df = pd.DataFrame(columns)
+        if search_vector is not None:
+            # Similarity
+
+            params = {
+                "queryVector": search_vector,
+                "column": TableField.EMBEDDINGS.value,
+                "similarityFunction": self._select_params["similarity_function"]
+            }
+            if filters:
+                params["filter"] = filters
+            if limit:
+                params["size"] = limit
+            results = self._client.data().vector_search(table_name, params)
+            # Check for errors
+            if not results.is_success():
+                raise Exception(results["message"])
+            # Convert result
+            results_df = pd.DataFrame.from_records(results["records"])
+            if "xata" in results_df.columns:
+                results_df["xata"] = results_df["xata"].apply(lambda x: x["score"])
+                results_df.rename({"xata": TableField.DISTANCE.value}, axis=1, inplace=True)
+
+        else:
+            # General get query
+
+            params = {
+                "columns": columns if columns else [],
+            }
+            if filters:
+                params["filter"] = filters
+            if limit or offset:
+                params["page"] = {}
+                if limit:
+                    params["page"]["size"] = limit
+                if offset:
+                    params["page"]["offset"] = offset
+            results = self._client.data().query(table_name, params)
+            # Check for errors
+            if not results.is_success():
+                raise Exception(results["message"])
+            # Convert result
+            results_df = pd.DataFrame.from_records(results["records"])
+            if "xata" in results_df.columns:
+                results_df.drop(["xata"], axis=1, inplace=True)
+
+        return results_df
+
+    def delete(self, table_name: str, conditions: List[FilterCondition] = None):
+        ids = []
+        for condition in conditions:
+            if condition.op == FilterOperator.EQUAL:
+                ids.append(condition.value)
+            else:
+                return Response(
+                    resp_type=RESPONSE_TYPE.ERROR,
+                    error_message="You can only delete using '=' operator ID one at a time!",
+                )
+
+        for id in ids:
+            resp = self._client.records().delete(table_name, id)
+            if not resp.is_success():
+                raise Exception(resp["message"])

mindsdb/integrations/handlers/youtube_handler/__about__.py

@@ -0,0 +1,9 @@
+__title__ = "MindsDB Youtube handler"
+__package_name__ = "mindsdb_youtube_handler"
+__version__ = "0.0.1"
+__description__ = "MindsDB handler for Youtube"
+__author__ = "Balaji Seetharaman"
+__github__ = "https://github.com/mindsdb/mindsdb"
+__pypi__ = "https://pypi.org/project/mindsdb/"
+__license__ = "MIT"
+__copyright__ = "Copyright 2023 - mindsdb"

mindsdb/integrations/handlers/youtube_handler/__init__.py

@@ -0,0 +1,27 @@
+from mindsdb.integrations.libs.const import HANDLER_TYPE
+
+
+from .__about__ import __version__ as version, __description__ as description
+
+try:
+    from .youtube_handler import YoutubeHandler as Handler
+    import_error = None
+except Exception as e:
+    Handler = None
+    import_error = e
+
+title = "YouTube"
+name = "youtube"
+type = HANDLER_TYPE.DATA
+icon_path = "icon.svg"
+
+__all__ = [
+    "Handler",
+    "version",
+    "name",
+    "type",
+    "title",
+    "description",
+    "import_error",
+    "icon_path",
+]

mindsdb/integrations/handlers/youtube_handler/icon.svg

@@ -0,0 +1,11 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="40" height="29" viewBox="0 0 40 29" fill="none">
+  <g clip-path="url(#clip0_155_2540)">
+    <path d="M39.1642 5.47816C38.7041 3.81238 37.3487 2.50034 35.6276 2.05502C32.5083 1.24609 20 1.24609 20 1.24609C20 1.24609 7.49168 1.24609 4.37219 2.05511C2.65123 2.50043 1.29583 3.81238 0.83583 5.47824C-8.29286e-08 8.49762 0 14.7975 0 14.7975C0 14.7975 -8.29286e-08 21.0976 0.83583 24.1168C1.29583 25.7827 2.65123 27.0401 4.37219 27.4855C7.49168 28.2944 20 28.2944 20 28.2944C20 28.2944 32.5083 28.2944 35.6276 27.4854C37.3487 27.04 38.7041 25.7826 39.1642 24.1168C40 21.0975 40 14.7975 40 14.7975C40 14.7975 40 8.49762 39.1642 5.47816Z" fill="#FF0000"/>
+    <path d="M15.9091 20.5178V9.07812L26.3635 14.7981L15.9091 20.5178Z" fill="white"/>
+  </g>
+  <defs>
+    <clipPath id="clip0_155_2540">
+      <rect width="40" height="28.5714" fill="white" transform="translate(0 0.214233)"/>
+    </clipPath>
+  </defs>
+</svg>

mindsdb/integrations/handlers/youtube_handler/requirements.txt

@@ -0,0 +1,2 @@
+google-api-python-client
+youtube-transcript-api

mindsdb/integrations/handlers/youtube_handler/youtube_handler.py

@@ -0,0 +1,164 @@
+from mindsdb.integrations.handlers.youtube_handler.youtube_tables import (
+    YoutubeCommentsTable,
+    YoutubeChannelsTable,
+    YoutubeVideosTable,
+)
+from mindsdb.integrations.libs.api_handler import APIHandler
+from mindsdb.integrations.libs.response import (
+    HandlerStatusResponse as StatusResponse,
+)
+from mindsdb.utilities import log
+from mindsdb_sql_parser import parse_sql
+
+from collections import OrderedDict
+from mindsdb.utilities.config import Config
+from mindsdb.integrations.libs.const import HANDLER_CONNECTION_ARG_TYPE as ARG_TYPE
+
+from googleapiclient.discovery import build
+
+from mindsdb.integrations.utilities.handlers.auth_utilities import GoogleUserOAuth2Manager
+
+DEFAULT_SCOPES = [
+	'https://www.googleapis.com/auth/youtube',
+	'https://www.googleapis.com/auth/youtube.force-ssl',
+	'https://www.googleapis.com/auth/youtubepartner'
+]
+
+logger = log.getLogger(__name__)
+
+
+class YoutubeHandler(APIHandler):
+    """Youtube handler implementation"""
+
+    def __init__(self, name=None, **kwargs):
+        """Initialize the Youtube handler.
+        Parameters
+        ----------
+        name : str
+            name of a handler instance
+        """
+        super().__init__(name)
+
+        connection_data = kwargs.get("connection_data", {})
+
+        self.parser = parse_sql
+        self.connection_data = connection_data
+        self.kwargs = kwargs
+        self.connection = None
+        self.is_connected = False
+
+        self.handler_storage = kwargs['handler_storage']
+
+        self.credentials_url = self.connection_data.get('credentials_url', None)
+        self.credentials_file = self.connection_data.get('credentials_file', None)
+        if self.connection_data.get('credentials'):
+            self.credentials_file = self.connection_data.pop('credentials')
+        if not self.credentials_file and not self.credentials_url:
+            # try to get from config
+            yt_config = Config().get('handlers', {}).get('youtube', {})
+            secret_file = yt_config.get('credentials_file')
+            secret_url = yt_config.get('credentials_url')
+            if secret_file:
+                self.credentials_file = secret_file
+            elif secret_url:
+                self.credentials_url = secret_url
+
+        self.youtube_api_token = self.connection_data.get('youtube_api_token', None)
+
+        self.scopes = self.connection_data.get('scopes', DEFAULT_SCOPES)
+
+        youtube_video_comments_data = YoutubeCommentsTable(self)
+        self._register_table("comments", youtube_video_comments_data)
+
+        youtube_channel_data = YoutubeChannelsTable(self)
+        self._register_table("channels", youtube_channel_data)
+
+        youtube_video_data = YoutubeVideosTable(self)
+        self._register_table("videos", youtube_video_data)
+
+    def connect(self) -> StatusResponse:
+        """Set up the connection required by the handler.
+        Returns
+        -------
+        StatusResponse
+            connection object
+        """
+        if self.is_connected is True:
+            return self.connection
+        
+        google_oauth2_manager = GoogleUserOAuth2Manager(self.handler_storage, self.scopes, self.credentials_file, self.credentials_url, self.connection_data.get('code'))
+        creds = google_oauth2_manager.get_oauth2_credentials()
+
+        youtube = build(
+            "youtube", "v3", developerKey=self.youtube_api_token, credentials=creds
+        )
+        self.connection = youtube
+
+        return self.connection
+
+    def check_connection(self) -> StatusResponse:
+        """Check connection to the handler.
+        Returns
+        -------
+        StatusResponse
+            Status confirmation
+        """
+        response = StatusResponse(False)
+        need_to_close = self.is_connected is False
+
+        try:
+            self.connect()
+            response.success = True
+            response.copy_storage = True
+        except Exception as e:
+            logger.error(f"Error connecting to Youtube API: {e}!")
+            response.error_message = e
+
+        self.is_connected = response.success
+
+        return response
+
+    def native_query(self, query: str) -> StatusResponse:
+        """Receive and process a raw query.
+        Parameters
+        ----------
+        query : str
+            query in a native format
+        Returns
+        -------
+        StatusResponse
+            Request status
+        """
+        ast = parse_sql(query)
+        return self.query(ast)
+
+
+connection_args = OrderedDict(
+    youtube_access_token={
+        "type": ARG_TYPE.STR,
+        "description": "API Key",
+        "label": "API Key",
+    },
+    credentials_url={
+        'type': ARG_TYPE.STR,
+        'description': 'URL to OAuth2 Credentials',
+        'label': 'URL to OAuth2 Credentials',
+    },
+    credentials_file={
+        'type': ARG_TYPE.STR,
+        'description': 'Location of OAuth2 Credentials',
+        'label': 'Location of OAuth2 Credentials',
+    },
+    credentials={
+        'type': ARG_TYPE.PATH,
+        'description': 'OAuth2 Credentials',
+        'label': 'Upload OAuth2 Credentials',
+    },
+    code={
+        'type': ARG_TYPE.STR,
+        'description': 'Authentication Code',
+        'label': 'Authentication Code',
+    }
+)
+
+connection_args_example = OrderedDict(youtube_api_token="<your-youtube-api-token>")