kaggle 1.7.4.2__py3-none-any.whl → 1.8.0__py3-none-any.whl

kagglesdk/kaggle_creds.py

@@ -0,0 +1,148 @@
+import json
+import os
+from datetime import datetime, timedelta, timezone
+from kagglesdk.kaggle_client import KaggleClient
+from kagglesdk.security.types.oauth_service import IntrospectTokenRequest
+from kagglesdk.users.types.account_service import (
+    ApiVersion,
+    GenerateAccessTokenRequest,
+    GenerateAccessTokenResponse,
+    ExpireApiTokenRequest,
+)
+
+
+class KaggleCredentials:
+    DEFAULT_CREDENTIALS_FILE = "~/.kaggle/credentials.json"
+    DEFAULT_ACCESS_TOKEN_EXPIRATION = timedelta(hours=12)
+
+    def __init__(
+        self,
+        client: KaggleClient,
+        refresh_token: str = None,
+        access_token: str = None,
+        access_token_expiration: datetime = None,
+        username: str = None,
+        scopes: list[str] = None,
+    ):
+        self._client = client
+        self._refresh_token = refresh_token
+        self._access_token = access_token
+        self._access_token_expiration = access_token_expiration
+        self._username = username
+        self._scopes = scopes if scopes is not None else []
+
+    @classmethod
+    def load(cls, client: KaggleClient, file_path: str = None) -> "KaggleCredentials":
+        file_path = os.path.expanduser(file_path or KaggleCredentials.DEFAULT_CREDENTIALS_FILE)
+        if not os.path.exists(file_path):
+            return None
+
+        try:
+            with open(file_path, "r") as f:
+                data = json.load(f)
+        except (json.JSONDecodeError, KeyError):
+            return None
+
+        refresh_token = data.get("refresh_token")
+        if not refresh_token:
+            return None
+
+        access_token_expiration = data.get("access_token_expiration")
+        if access_token_expiration:
+            access_token_expiration = datetime.fromisoformat(access_token_expiration)
+        else:
+            access_token_expiration = None
+
+        return cls(
+            client=client,
+            refresh_token=refresh_token,
+            access_token=data.get("access_token"),
+            access_token_expiration=access_token_expiration,
+            username=data.get("username"),
+            scopes=data.get("scopes"),
+        )
+
+    def delete(self, file_path=DEFAULT_CREDENTIALS_FILE) -> None:
+        file_path = os.path.expanduser(file_path)
+        if os.path.exists(file_path):
+            os.remove(file_path)
+
+    def save(self, file_path=DEFAULT_CREDENTIALS_FILE) -> None:
+        if not self._refresh_token:
+            raise Exception("Missing refresh token")
+
+        file_path = os.path.expanduser(file_path)
+        dir_name = os.path.dirname(file_path)
+        if not os.path.exists(dir_name):
+            os.makedirs(dir_name)
+
+        data = {
+            "refresh_token": self._refresh_token,
+            "access_token": self._access_token or "",
+            "access_token_expiration": (
+                self._access_token_expiration.isoformat() if self._access_token_expiration else ""
+            ),
+            "username": self._username or "",
+            "scopes": self._scopes or [],
+        }
+
+        with open(file_path, "w") as f:
+            json.dump(data, f, indent=2)
+
+        try:
+            os.chmod(file_path, 0o600)
+        except OSError:
+            pass  # Ignore errors, especially on Windows
+
+    def introspect(self) -> str:
+        request = IntrospectTokenRequest()
+        request.token = self._access_token
+        response = self._client.security.oauth_client.introspect_token(request)
+
+        if not response.active or not response.username:
+            raise Exception("Authentication failed.")
+
+        self._username = response.username
+        return response.username
+
+    def refresh_access_token(self) -> None:
+        if not self._refresh_token:
+            raise Exception("Missing refresh token")
+
+        response = self.generate_access_token()
+        self._access_token_expiration = datetime.now(timezone.utc) + timedelta(seconds=response.expires_in)
+        self._access_token = response.token
+        self.save()
+
+    def access_token_has_expired(self) -> bool:
+        return not self._access_token_expiration or self._access_token_expiration < datetime.now(
+            timezone.utc
+        ) - timedelta(minutes=30)
+
+    def get_access_token(self) -> str:
+        if not self._access_token or self.access_token_has_expired():
+            if not self._refresh_token:
+                return None
+            self.refresh_access_token()
+        return self._access_token
+
+    def generate_access_token(self, expiration_duration: timedelta = None) -> GenerateAccessTokenResponse:
+        if not self._refresh_token:
+            return None
+        request = GenerateAccessTokenRequest()
+        request.refresh_token = self._refresh_token
+        request.api_version = ApiVersion.API_VERSION_V1
+        request.expiration_duration = expiration_duration or KaggleCredentials.DEFAULT_ACCESS_TOKEN_EXPIRATION
+        return self._client.users.account_client.generate_access_token(request)
+
+    def revoke_token(self, reason: str) -> None:
+        if not self._refresh_token:
+            return
+        request = ExpireApiTokenRequest()
+        request.token = self._refresh_token
+        request.reason = reason
+        self._client.users.account_client.expire_api_token(request)
+        self.delete()
+
+    def get_username(self) -> str:
+        return self._username

kagglesdk/kaggle_env.py

@@ -1,42 +1,104 @@
+import logging
 import os
 from enum import Enum
+from pathlib import Path
+
+KAGGLE_NOTEBOOK_ENV_VAR_NAME = "KAGGLE_KERNEL_RUN_TYPE"
+KAGGLE_DATA_PROXY_URL_ENV_VAR_NAME = "KAGGLE_DATA_PROXY_URL"
+KAGGLE_API_V1_TOKEN_PATH = "KAGGLE_API_V1_TOKEN"
+
+
+def get_logger():
+    return logging.getLogger(__name__)
 
 
 class KaggleEnv(Enum):
-  LOCAL = 0  # localhost
-  STAGING = 1  # staging.kaggle.com
-  ADMIN = 2  # admin.kaggle.com
-  QA = 3 # qa.kaggle.com
-  # Direct prod access is not allowed to have IAP protection during testing, but we support basic auth.
-  PROD = 4  # www.kaggle.com
+    LOCAL = 0  # localhost
+    STAGING = 1  # staging.kaggle.com
+    ADMIN = 2  # admin.kaggle.com
+    QA = 3  # qa.kaggle.com
+    PROD = 4  # api.kaggle.com
 
 
 _env_to_endpoint = {
-  KaggleEnv.LOCAL: 'http://localhost',
-  KaggleEnv.STAGING: 'https://staging.kaggle.com',
-  KaggleEnv.ADMIN: 'https://admin.kaggle.com',
-  KaggleEnv.QA: 'https://qa.kaggle.com',
-  # See the comment above in KaggleEnv enum.
-  KaggleEnv.PROD: "https://www.kaggle.com",
+    KaggleEnv.LOCAL: "http://localhost",
+    KaggleEnv.STAGING: "https://staging.kaggle.com",
+    KaggleEnv.ADMIN: "https://admin.kaggle.com",
+    KaggleEnv.QA: "https://qa.kaggle.com",
+    KaggleEnv.PROD: "https://api.kaggle.com",
 }
 
 
 def get_endpoint(env: KaggleEnv):
-  return _env_to_endpoint[env]
+    return _env_to_endpoint[env]
 
 
 def get_env():
-  env = os.getenv('KAGGLE_API_ENVIRONMENT')
-  if env is None:
-    raise Exception('Must specify KaggleEnv or set KAGGLE_API_ENVIRONMENT env var')
-  if env == 'LOCALHOST':
-    return KaggleEnv.LOCAL
-  if env == 'ADMIN':
-    return KaggleEnv.ADMIN
-  if env == 'STAGING':
-    return KaggleEnv.STAGING
-  if env == 'QA':
-    return KaggleEnv.QA
-  if env == 'PROD':
-    return KaggleEnv.PROD
-  raise Exception(f'Unrecognized value in KAGGLE_API_ENVIRONMENT: "{env}"')
+    env = os.getenv("KAGGLE_API_ENVIRONMENT")
+    if env is None or env == "PROD":
+        return KaggleEnv.PROD
+    if env == "LOCALHOST":
+        return KaggleEnv.LOCAL
+    if env == "ADMIN":
+        return KaggleEnv.ADMIN
+    if env == "STAGING":
+        return KaggleEnv.STAGING
+    if env == "QA":
+        return KaggleEnv.QA
+    raise Exception(f'Unrecognized value in KAGGLE_API_ENVIRONMENT: "{env}"')
+
+
+def is_in_kaggle_notebook() -> bool:
+    if os.getenv(KAGGLE_NOTEBOOK_ENV_VAR_NAME) is not None:
+        if os.getenv(KAGGLE_DATA_PROXY_URL_ENV_VAR_NAME) is None:
+            # Missing endpoint for the Jwt client
+            get_logger().warning(
+                "Can't use the Kaggle Cache. "
+                f"The '{KAGGLE_DATA_PROXY_URL_ENV_VAR_NAME}' environment variable is not set."
+            )
+            return False
+        return True
+    return False
+
+
+def _get_access_token_from_file(path):
+    if not path:
+        return None
+
+    token_path = Path(path)
+    if not token_path.exists():
+        return None
+
+    token_value = token_path.read_text().strip()
+    if not token_value:
+        return None
+
+    get_logger().debug(f'Using access token from file: "{path}"')
+    return token_value
+
+
+def get_access_token_from_env():
+    if is_in_kaggle_notebook():
+        token = _get_access_token_from_file(os.environ.get(KAGGLE_API_V1_TOKEN_PATH))
+        if token:
+            return (token, KAGGLE_API_V1_TOKEN_PATH)
+
+    access_token = os.environ.get("KAGGLE_API_TOKEN")
+    if access_token:
+        if Path(access_token).exists():
+            return (_get_access_token_from_file(access_token), "KAGGLE_API_TOKEN")
+        get_logger().debug(
+            "Using access token from KAGGLE_API_TOKEN environment variable"
+        )
+        return (access_token, "KAGGLE_API_TOKEN")
+
+    access_token = _get_access_token_from_file(os.path.expanduser("~/.kaggle/access_token"))
+    if access_token:
+        return (access_token, "access_token")
+
+    # Check ".txt" as well in case Windows users create the file with this extension.
+    access_token = _get_access_token_from_file(os.path.expanduser("~/.kaggle/access_token.txt"))
+    if access_token:
+        return (access_token, "access_token")
+
+    return (None, None)