GCP ML services integration. (#925)

* Cloud Translation, Natural language, Vision,
Video intelligence GCP integrations.

* Fixes for style guide

Author: kornelregius

Dockerfile

@@ -268,6 +268,10 @@ RUN pip install --upgrade cython && \
     # which is loaded at startup.
     pip install google-cloud-bigquery==1.12.1 && \
     pip install google-cloud-storage && \
+    pip install google-cloud-translate==3.* && \
+    pip install google-cloud-language==2.* && \
+    pip install google-cloud-videointelligence==2.* && \
+    pip install google-cloud-vision==2.* && \
     pip install ortools && \
     pip install scattertext && \
     # Pandas data reader

patches/kaggle_gcp.py

@@ -1,6 +1,6 @@
 import os
 import inspect
-from google.auth import credentials
+from google.auth import credentials, environment_vars
 from google.auth.exceptions import RefreshError
 from google.api_core.gapic_v1.client_info import ClientInfo
 from google.cloud import bigquery
@@ -22,7 +22,7 @@ def get_integrations():
             target = GcpTarget[integration.upper()]
             kernel_integrations.add_integration(target)
         except KeyError as e:
-            Log.error(f"Unknown integration target: {e}")
+            Log.error(f"Unknown integration target: {integration.upper()}")
     return kernel_integrations
 
 
@@ -45,6 +45,17 @@ def has_gcs(self):
     def has_automl(self):
         return GcpTarget.AUTOML in self.integrations
 
+    def has_translation(self):
+        return GcpTarget.TRANSLATION in self.integrations
+
+    def has_natural_language(self):
+        return GcpTarget.NATURAL_LANGUAGE in self.integrations
+
+    def has_video_intelligence(self):
+        return GcpTarget.VIDEO_INTELLIGENCE in self.integrations
+
+    def has_vision(self):
+        return GcpTarget.VISION in self.integrations
 
 class KaggleKernelCredentials(credentials.Credentials):
     """Custom Credentials used to authenticate using the Kernel's connected OAuth account.
@@ -65,6 +76,14 @@ def refresh(self, request):
                 self.token, self.expiry = client._get_gcs_access_token()
             elif self.target == GcpTarget.AUTOML:
                 self.token, self.expiry = client._get_automl_access_token()
+            elif self.target == GcpTarget.TRANSLATION:
+                self.token, self.expiry = client._get_translation_access_token()
+            elif self.target == GcpTarget.NATURAL_LANGUAGE:
+                self.token, self.expiry = client._get_natural_language_access_token()
+            elif self.target == GcpTarget.VIDEO_INTELLIGENCE:
+                self.token, self.expiry = client._get_video_intelligence_access_token()
+            elif self.target == GcpTarget.VISION:
+                self.token, self.expiry = client._get_vision_access_token()
         except ConnectionError as e:
             Log.error(f"Connection error trying to refresh access token: {e}")
             print("There was a connection error trying to fetch the access token. "
@@ -78,6 +97,12 @@ def refresh(self, request):
                    f"Please ensure you have selected a {self.target.service} account in the Notebook Add-ons menu.")
             raise RefreshError('Unable to refresh access token.') from e
 
+class KaggleKernelWithProjetCredentials(KaggleKernelCredentials):
+    """ Wrapper Kaggle Credentials with quota_project_id.
+    """
+    def __init__(self, parentCredential=None, quota_project_id=None):
+        super().__init__(target=parentCredential.target)
+        self._quota_project_id=quota_project_id
 
 class _DataProxyConnection(Connection):
     """Custom Connection class used to proxy the BigQuery client to Kaggle's data proxy."""
@@ -122,13 +147,16 @@ def __init__(self, *args, **kwargs):
 def has_been_monkeypatched(method):
     return "kaggle_gcp" in inspect.getsourcefile(method)
 
+def is_user_secrets_token_set():
+    return "KAGGLE_USER_SECRETS_TOKEN" in os.environ
+
+def is_proxy_token_set():
+    return "KAGGLE_DATA_PROXY_TOKEN" in os.environ
+
 def init_bigquery():
-    from google.auth import environment_vars
     from google.cloud import bigquery
 
-    is_proxy_token_set = "KAGGLE_DATA_PROXY_TOKEN" in os.environ
-    is_user_secrets_token_set = "KAGGLE_USER_SECRETS_TOKEN" in os.environ
-    if not (is_proxy_token_set or is_user_secrets_token_set):
+    if not (is_proxy_token_set() or is_user_secrets_token_set()):
         return bigquery
 
     # If this Notebook has bigquery integration on startup, preload the Kaggle Credentials
@@ -185,14 +213,24 @@ def patched_init(self, *args, **kwargs):
         specified_credentials = kwargs.get('credentials')
         if specified_credentials is None:
             Log.info("No credentials specified, using KaggleKernelCredentials.")
-            kwargs['credentials'] = kaggle_kernel_credentials
+            # Some GCP services demand the billing and target project must be the same.
+            # To avoid using default service account based credential as caller credential
+            # user need to provide ClientOptions with quota_project_id:
+            # srv.Client(client_options=client_options.ClientOptions(quota_project_id="YOUR PROJECT"))
+            client_options=kwargs.get('client_options')
+            if client_options != None and client_options.quota_project_id != None:
+                kwargs['credentials'] = KaggleKernelWithProjetCredentials(
+                    parentCredential = kaggle_kernel_credentials,
+                    quota_project_id = client_options.quota_project_id)
+            else:
+                kwargs['credentials'] = kaggle_kernel_credentials
 
         kwargs['client_info'] = set_kaggle_user_agent(kwargs.get('client_info'))
-
         return client_init(self, *args, **kwargs)
 
     if (not has_been_monkeypatched(client_klass.__init__)):
         client_klass.__init__ = patched_init
+        Log.info(f"Client patched: {client_klass}")
 
 def set_kaggle_user_agent(client_info: ClientInfo):
     # Add kaggle client user agent in order to attribute usage.
@@ -203,9 +241,8 @@ def set_kaggle_user_agent(client_info: ClientInfo):
     return client_info
 
 def init_gcs():
-    is_user_secrets_token_set = "KAGGLE_USER_SECRETS_TOKEN" in os.environ
     from google.cloud import storage
-    if not is_user_secrets_token_set:
+    if not is_user_secrets_token_set():
         return storage
 
     from kaggle_gcp import get_integrations
@@ -220,9 +257,8 @@ def init_gcs():
     return storage
 
 def init_automl():
-    is_user_secrets_token_set = "KAGGLE_USER_SECRETS_TOKEN" in os.environ
     from google.cloud import automl, automl_v1beta1
-    if not is_user_secrets_token_set:
+    if not is_user_secrets_token_set():
         return
 
     from kaggle_gcp import get_integrations
@@ -251,10 +287,91 @@ def init_automl():
     # the TablesClient is GA.
     monkeypatch_client(automl_v1beta1.TablesClient, kaggle_kernel_credentials)
 
+def init_translation_v2():
+    from google.cloud import translate_v2
+    if not is_user_secrets_token_set():
+        return translate_v2
+
+    from kaggle_gcp import get_integrations
+    if not get_integrations().has_translation():
+        return translate_v2
+    from kaggle_secrets import GcpTarget
+    kernel_credentials = KaggleKernelCredentials(target=GcpTarget.TRANSLATION)
+    monkeypatch_client(translate_v2.Client, kernel_credentials)
+    return translate_v2
+
+def init_translation_v3():
+    # Translate v3 exposes different client than translate v2.
+    from google.cloud import translate_v3
+    if not is_user_secrets_token_set():
+        return translate_v3
+
+    from kaggle_gcp import get_integrations
+    if not get_integrations().has_translation():
+        return translate_v3
+    from kaggle_secrets import GcpTarget
+    kernel_credentials = KaggleKernelCredentials(target=GcpTarget.TRANSLATION)
+    monkeypatch_client(translate_v3.TranslationServiceClient, kernel_credentials)
+    return translate_v3
+
+def init_natural_language():
+    from google.cloud import language
+    if not is_user_secrets_token_set():
+        return language
+
+    from kaggle_gcp import get_integrations
+    if not get_integrations().has_natural_language():
+        return language
+
+    from kaggle_secrets import GcpTarget
+    kernel_credentials = KaggleKernelCredentials(target=GcpTarget.NATURAL_LANGUAGE)
+    monkeypatch_client(language.LanguageServiceClient, kernel_credentials)    
+    monkeypatch_client(language.LanguageServiceAsyncClient, kernel_credentials)
+    return language
+
+def init_video_intelligence():
+    from google.cloud import videointelligence
+    if not is_user_secrets_token_set():
+        return videointelligence
+
+    from kaggle_gcp import get_integrations
+    if not get_integrations().has_video_intelligence():
+        return videointelligence
+
+    from kaggle_secrets import GcpTarget
+    kernel_credentials = KaggleKernelCredentials(target=GcpTarget.VIDEO_INTELLIGENCE)
+    monkeypatch_client(
+        videointelligence.VideoIntelligenceServiceClient,
+        kernel_credentials)
+    monkeypatch_client(
+        videointelligence.VideoIntelligenceServiceAsyncClient,
+        kernel_credentials)
+    return videointelligence
+
+def init_vision():
+    from google.cloud import vision
+    if not is_user_secrets_token_set():
+        return vision
+
+    from kaggle_gcp import get_integrations
+    if not get_integrations().has_vision():
+        return vision
+
+    from kaggle_secrets import GcpTarget
+    kernel_credentials = KaggleKernelCredentials(target=GcpTarget.VISION)
+    monkeypatch_client(vision.ImageAnnotatorClient, kernel_credentials)
+    monkeypatch_client(vision.ImageAnnotatorAsyncClient, kernel_credentials)
+    return vision
+
 def init():
     init_bigquery()
     init_gcs()
     init_automl()
+    init_translation_v2()
+    init_translation_v3()
+    init_natural_language()
+    init_video_intelligence()
+    init_vision()
 
 # We need to initialize the monkeypatching of the client libraries
 # here since there is a circular dependency between our import hook version

patches/kaggle_secrets.py

@@ -24,6 +24,10 @@ class GcpTarget(Enum):
     BIGQUERY = (1, "BigQuery")
     GCS = (2, "Google Cloud Storage")
     AUTOML = (3, "Cloud AutoML")
+    TRANSLATION = (4, "Cloud Translation")
+    NATURAL_LANGUAGE = (5, "Cloud Natural Language")
+    VIDEO_INTELLIGENCE = (6, "Cloud Video Intelligence")
+    VISION = (7, "Cloud Vision")
 
     def __init__(self, target, service):
         self._target = target
@@ -154,6 +158,18 @@ def _get_gcs_access_token(self) -> Tuple[str, Optional[datetime]]:
     def _get_automl_access_token(self) -> Tuple[str, Optional[datetime]]:
         return self._get_access_token(GcpTarget.AUTOML)
 
+    def _get_translation_access_token(self) -> Tuple[str, Optional[datetime]]:
+        return self._get_access_token(GcpTarget.TRANSLATION)
+
+    def _get_natural_language_access_token(self) -> Tuple[str, Optional[datetime]]:
+        return self._get_access_token(GcpTarget.NATURAL_LANGUAGE)
+
+    def _get_video_intelligence_access_token(self) -> Tuple[str, Optional[datetime]]:
+        return self._get_access_token(GcpTarget.VIDEO_INTELLIGENCE)
+
+    def _get_vision_access_token(self) -> Tuple[str, Optional[datetime]]:
+        return self._get_access_token(GcpTarget.VISION)
+
     def _get_access_token(self, target: GcpTarget) -> Tuple[str, Optional[datetime]]:
         request_body = {
             'Target': target.target

patches/sitecustomize.py

@@ -7,7 +7,20 @@
 import importlib.machinery
 
 class GcpModuleFinder(importlib.abc.MetaPathFinder):
-    _MODULES = ['google.cloud.bigquery', 'google.cloud.storage', 'google.cloud.automl_v1beta1']
+    _MODULES = [
+        'google.cloud.bigquery',
+        'google.cloud.storage',
+        'google.cloud.automl_v1beta1',
+        'google.cloud.translate',
+        'google.cloud.translate_v2',
+        'google.cloud.translate_v3',
+        'google.cloud.language',
+        'google.cloud.language_v1',
+        'google.cloud.videointelligence',
+        'google.cloud.videointelligence_v1',
+        'google.cloud.vision',
+        'google.cloud.vision_v1',
+    ]
     _KAGGLE_GCP_PATH = 'kaggle_gcp.py'
     def __init__(self):
         pass
@@ -41,13 +54,21 @@ def create_module(self, spec):
             'google.cloud.bigquery': kaggle_gcp.init_bigquery,
             'google.cloud.storage': kaggle_gcp.init_gcs,
             'google.cloud.automl_v1beta1': kaggle_gcp.init_automl,
+            'google.cloud.translate': kaggle_gcp.init_translation_v3,
+            'google.cloud.translate_v2': kaggle_gcp.init_translation_v2,
+            'google.cloud.translate_v3': kaggle_gcp.init_translation_v3,
+            'google.cloud.language': kaggle_gcp.init_natural_language,
+            'google.cloud.language_v1': kaggle_gcp.init_natural_language,
+            'google.cloud.videointelligence': kaggle_gcp.init_video_intelligence,
+            'google.cloud.videointelligence_v1': kaggle_gcp.init_video_intelligence,
+            'google.cloud.vision': kaggle_gcp.init_vision,
+            'google.cloud.vision_v1': kaggle_gcp.init_vision
         }
         monkeypatch_gcp_module = _LOADERS[spec.name]()
         return monkeypatch_gcp_module
 
     def exec_module(self, module):
         pass
 
-
 if not hasattr(sys, 'frozen'):
     sys.meta_path.insert(0, GcpModuleFinder())

tests/test_natural_language.py

@@ -0,0 +1,67 @@
+import unittest
+import inspect
+
+from unittest.mock import Mock, patch
+
+from kaggle_gcp import KaggleKernelCredentials, init_natural_language
+from test.support import EnvironmentVarGuard
+from google.cloud import language
+
+def _make_credentials():
+    import google.auth.credentials
+    return Mock(spec=google.auth.credentials.Credentials)
+
+class TestCloudNaturalLanguage(unittest.TestCase):
+    class FakeClient:
+        def __init__(self, credentials=None, client_info=None, **kwargs):
+            self.credentials = credentials
+
+            class FakeConnection():
+                def __init__(self, user_agent):
+                    self.user_agent = user_agent
+            if (client_info is not None):
+                self._connection = FakeConnection(client_info.user_agent)
+
+    @patch("google.cloud.language.LanguageServiceClient", new=FakeClient)
+    def test_default_credentials(self):
+        env = EnvironmentVarGuard()
+        env.set('KAGGLE_USER_SECRETS_TOKEN', 'foobar')
+        env.set('KAGGLE_KERNEL_INTEGRATIONS', 'NATURAL_LANGUAGE')
+        with env:
+            init_natural_language()
+            client = language.LanguageServiceClient()
+            self.assertIsNotNone(client.credentials)
+            self.assertIsInstance(client.credentials, KaggleKernelCredentials)
+
+    @patch("google.cloud.language.LanguageServiceClient", new=FakeClient)
+    def test_user_provided_credentials(self):
+        credentials = _make_credentials()
+        env = EnvironmentVarGuard()
+        env.set('KAGGLE_USER_SECRETS_TOKEN', 'foobar')
+        env.set('KAGGLE_KERNEL_INTEGRATIONS', 'NATURAL_LANGUAGE')
+        with env:
+            init_natural_language()
+            client = language.LanguageServiceClient(credentials=credentials)
+            self.assertIsNotNone(client.credentials)
+            self.assertNotIsInstance(client.credentials, KaggleKernelCredentials)
+
+
+    def test_monkeypatching_succeed(self):
+        env = EnvironmentVarGuard()
+        env.set('KAGGLE_USER_SECRETS_TOKEN', 'foobar')
+        env.set('KAGGLE_KERNEL_INTEGRATIONS', 'TRANSLATION')
+        with env:
+            init_natural_language()
+            client = language.LanguageServiceClient.__init__
+            self.assertTrue("kaggle_gcp" in inspect.getsourcefile(client))
+   
+    def test_monkeypatching_idempotent(self):
+        env = EnvironmentVarGuard()
+        env.set('KAGGLE_USER_SECRETS_TOKEN', 'foobar')
+        env.set('KAGGLE_KERNEL_INTEGRATIONS', 'NATURAL_LANGUAGE')
+        with env:
+            init_natural_language()
+            client1 = language.LanguageServiceClient.__init__
+            init_natural_language()
+            client2 = language.LanguageServiceClient.__init__
+            self.assertEqual(client1, client2)