kaggle 1.8.2__py3-none-any.whl → 1.8.4__py3-none-any.whl

kagglesdk/kaggle_env.py

@@ -1,104 +0,0 @@
-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
-    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",
-    KaggleEnv.PROD: "https://api.kaggle.com",
-}
-
-
-def get_endpoint(env: KaggleEnv):
-    return _env_to_endpoint[env]
-
-
-def get_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)

kagglesdk/kaggle_http_client.py

@@ -1,269 +0,0 @@
-import binascii
-import codecs
-import json
-import os
-import urllib.parse
-from io import BytesIO
-from pathlib import Path
-
-import requests
-from urllib3.fields import RequestField
-
-from kagglesdk.kaggle_env import (
-    get_endpoint,
-    get_env,
-    get_access_token_from_env,
-    KaggleEnv,
-)
-from kagglesdk.kaggle_object import KaggleObject
-from kagglesdk.common.types.file_download import FileDownload
-from kagglesdk.common.types.http_redirect import HttpRedirect
-from typing import Type
-
-# TODO (http://b/354237483) Generate the client from the existing one.
-# This was created from kaggle_api_client.py, prior to recent changes to
-# auth handling. The new client requires KAGGLE_API_TOKEN, so it is not
-# currently usable by the CLI.
-
-
-def _headers_to_str(headers):
-    return "\n".join(f"{k}: {v}" for k, v in headers.items())
-
-
-def _get_apikey_creds():
-    apikey_filename = os.path.expanduser("~/.kaggle/kaggle.json")
-    if not os.path.exists(apikey_filename):
-        return None
-
-    kaggle_json = None
-    with open(apikey_filename) as apikey_file:
-        kaggle_json = apikey_file.read()
-
-    if not kaggle_json or not kaggle_json.strip():
-        return None
-
-    api_key_data = json.loads(kaggle_json)
-    username = api_key_data["username"]
-    api_key = api_key_data["key"]
-    return username, api_key
-
-
-class KaggleHttpClient(object):
-    _xsrf_cookie_name = "XSRF-TOKEN"
-    _csrf_cookie_name = "CSRF-TOKEN"
-    _xsrf_cookies = (_xsrf_cookie_name, _csrf_cookie_name)
-    _xsrf_header_name = "X-XSRF-TOKEN"
-
-    def __init__(
-        self,
-        env: KaggleEnv = None,
-        verbose: bool = False,
-        username: str = None,
-        password: str = None,
-        api_token: str = None,
-    ):
-        self._env = env or get_env()
-        self._signed_in = None
-        self._endpoint = get_endpoint(self._env)
-        self._verbose = verbose
-        self._session = None
-        self._username = username
-        self._password = password
-        self._api_token = api_token
-
-    def call(
-        self,
-        service_name: str,
-        request_name: str,
-        request: KaggleObject,
-        response_type: Type[KaggleObject],
-    ):
-        self._init_session()
-        http_request = self._prepare_request(service_name, request_name, request)
-
-        # Merge environment settings into session
-        settings = self._session.merge_environment_settings(http_request.url, {}, None, None, None)
-
-        # Use stream=True for file downloads to avoid loading entire file into memory
-        # See: https://github.com/Kaggle/kaggle-api/issues/754
-        if response_type is not None and (response_type == FileDownload or response_type == HttpRedirect):
-            settings["stream"] = True
-
-        http_response = self._session.send(http_request, **settings)
-
-        response = self._prepare_response(response_type, http_response)
-        return response
-
-    def _prepare_request(self, service_name: str, request_name: str, request: KaggleObject):
-        request_url = self._get_request_url(service_name, request_name)
-        http_request = requests.Request(
-            method="POST",
-            url=request_url,
-            json=request.__class__.to_dict(request),
-            headers=self._session.headers,
-            auth=self._session.auth,
-        )
-        prepared_request = http_request.prepare()
-        self._print_request(prepared_request)
-        return prepared_request
-
-    def _prepare_response(self, response_type, http_response):
-        """Extract the kaggle response and raise an exception if it is an error."""
-        self._print_response(http_response)
-        try:
-            if "application/json" in http_response.headers["Content-Type"]:
-                resp = http_response.json()
-                if "code" in resp and resp["code"] >= 400:
-                    raise requests.exceptions.HTTPError(resp["message"], response=http_response)
-        except KeyError:
-            pass
-        http_response.raise_for_status()
-        if response_type is None:  # Method doesn't have a return type
-            return None
-        return response_type.prepare_from(http_response)
-
-    def _print_request(self, request):
-        if not self._verbose:
-            return
-        self._print("---------------------Request----------------------")
-        self._print(f"{request.method} {request.url}\n{_headers_to_str(request.headers)}\n\n{request.body}")
-        self._print("--------------------------------------------------")
-
-    def _print_response(self, response, body=True):
-        if not self._verbose:
-            return
-        self._print("---------------------Response---------------------")
-        self._print(f"{response.status_code}\n{_headers_to_str(response.headers)}")
-        if body:
-            self._print(f"\n{response.text}")
-        self._print("--------------------------------------------------")
-
-    def _print(self, message: str):
-        if self._verbose:
-            print(message)
-
-    def __enter__(self):
-        self._init_session()
-        return self
-
-    def __exit__(self, exc_type, exc_value, tb):
-        if self._session is not None:
-            self._session.close()
-
-    def _init_session(self):
-        if self._session is not None:
-            return self._session
-
-        self._session = requests.Session()
-        self._session.headers.update({"User-Agent": "kaggle-api/v1.8.0", "Content-Type": "application/json"})  # Was: V2
-
-        iap_token = self._get_iap_token_if_required()
-        if iap_token is not None:
-            self._session.headers.update(
-                {
-                    # https://cloud.google.com/iap/docs/authentication-howto#authenticating_from_proxy-authorization_header
-                    "Proxy-Authorization": f"Bearer {iap_token}",
-                }
-            )
-
-        self._try_fill_auth()
-        # self._fill_xsrf_token(iap_token)  # TODO Make this align with original handler.
-
-    def _get_iap_token_if_required(self):
-        if self._env not in (KaggleEnv.STAGING, KaggleEnv.ADMIN):
-            return None
-        iap_token = os.getenv("KAGGLE_IAP_TOKEN")
-        if iap_token is None:
-            raise Exception(f'Must set KAGGLE_IAP_TOKEN to access "{self._endpoint}"')
-        return iap_token
-
-    def _fill_xsrf_token(self, iap_token):
-        initial_get_request = requests.Request(
-            method="GET",
-            url=self._endpoint,
-            headers=self._session.headers,
-            auth=self._session.auth,
-        )
-        prepared_request = initial_get_request.prepare()
-        self._print_request(prepared_request)
-
-        http_response = self._session.send(prepared_request)
-
-        self._print_response(http_response, body=False)
-        if iap_token is not None and http_response.status_code in (401, 403):
-            raise requests.exceptions.HTTPError("IAP token invalid or expired")
-        http_response.raise_for_status()
-
-        self._session.headers.update(
-            {
-                KaggleHttpClient._xsrf_header_name: self._session.cookies[KaggleHttpClient._xsrf_cookie_name],
-            }
-        )
-
-    def build_start_oauth_url(
-        self,
-        client_id: str,
-        redirect_uri: str,
-        scope: list[str],
-        state: str,
-        code_challenge: str,
-    ) -> str:
-        params = {
-            "response_type": "code",
-            "client_id": client_id,
-            "redirect_uri": redirect_uri,
-            "scope": " ".join(scope),
-            "state": state,
-            "code_challenge": code_challenge,
-            "code_challenge_method": "S256",
-            "response_type": "code",
-            "response_mode": "query",
-        }
-        auth_url = f"{self.get_non_api_endpoint()}/api/v1/oauth2/authorize"
-        query_string = urllib.parse.urlencode(params, quote_via=urllib.parse.quote_plus)
-        return f"{auth_url}?{query_string}"
-
-    def get_oauth_default_redirect_url(self) -> str:
-        return f"{self.get_non_api_endpoint()}/account/api/oauth/token"
-
-    def get_non_api_endpoint(self) -> str:
-        return "https://www.kaggle.com" if self._env == KaggleEnv.PROD else self._endpoint
-
-    class BearerAuth(requests.auth.AuthBase):
-
-        def __init__(self, token):
-            self.token = token
-
-        def __call__(self, r):
-            r.headers["Authorization"] = f"Bearer {self.token}"
-            return r
-
-    def _try_fill_auth(self):
-        if self._signed_in is not None:
-            return
-
-        if self._api_token is None:
-            (api_token, _) = get_access_token_from_env()
-            self._api_token = api_token
-
-        if self._api_token is not None:
-            self._session.auth = KaggleHttpClient.BearerAuth(self._api_token)
-            self._signed_in = True
-            return
-
-        if self._username and self._password:
-            apikey_creds = self._username, self._password
-        else:
-            apikey_creds = _get_apikey_creds()
-        if apikey_creds is not None:
-            self._session.auth = apikey_creds
-            self._signed_in = True
-            return
-
-        self._signed_in = False
-
-    def _get_request_url(self, service_name: str, request_name: str):
-        # On prod, API endpoints are served under https://api.kaggle.com/v1,
-        # but on staging/admin/local, they are served under http://localhost/api/v1.
-        base_url = self._endpoint if self._env == KaggleEnv.PROD else f"{self._endpoint}/api"
-        return f"{base_url}/v1/{service_name}/{request_name}"

kagglesdk/kaggle_oauth.py

@@ -1,200 +0,0 @@
-import base64
-import hashlib
-import http.server
-import logging
-import os
-import platform
-import random
-import secrets
-import socketserver
-import uuid
-import urllib.parse
-import webbrowser
-from datetime import datetime, timedelta, timezone
-from kagglesdk.kaggle_client import KaggleClient
-from kagglesdk.kaggle_creds import KaggleCredentials
-from kagglesdk.security.types.oauth_service import ExchangeOAuthTokenRequest
-
-
-class KaggleOAuth:
-    OAUTH_CLIENT_ID = "kagglesdk"
-
-    def __init__(self, client: KaggleClient):
-        self._client = client
-        self._http_client = client.http_client()
-        self._server_running = False
-        self._creds = None
-        self._logger = logging.getLogger(__name__)
-
-    class OAuthState:
-        def __init__(self):
-            self.state = str(uuid.uuid4())
-            self.code_verifier = KaggleOAuth.OAuthState._generate_code_verifier()
-            self.code_challenge = KaggleOAuth.OAuthState._generate_code_challenge(self.code_verifier)
-
-        def _generate_state(length: int = 32):
-            return secrets.token_urlsafe(length)
-
-        def _generate_code_verifier(length: int = 64) -> str:
-            if not 42 <= length <= 128:
-                raise ValueError("Code verifier length must be between 42 and 128 characters.")
-            return secrets.token_urlsafe(length)
-
-        def _generate_code_challenge(code_verifier: str) -> str:
-            code_verifier_bytes = code_verifier.encode("utf-8")
-            code_challenge_bytes = hashlib.sha256(code_verifier_bytes).digest()
-            code_challenge_base64 = base64.urlsafe_b64encode(code_challenge_bytes).decode("utf-8")
-            return code_challenge_base64
-
-    class OAuthCallbackHandler(http.server.BaseHTTPRequestHandler):
-        def __init__(
-            self,
-            *args,
-            oauth: "KaggleOAuth" = None,
-            oauth_state: "KaggleOAuth.OAuthState" = None,
-            on_success=None,
-            logger=None,
-            **kwargs,
-        ):
-            self._oauth = oauth
-            self._oauth_state = oauth_state
-            self._on_success = on_success
-            self._logger = logger
-            super().__init__(*args, **kwargs)
-
-        def do_GET(self):
-            if self.path == "/favicon.ico":
-                return
-            try:
-                self._handle_oauth_callback()
-            finally:
-                self._stop_server()
-
-        def _handle_oauth_callback(self):
-            parsed_url = urllib.parse.urlparse(self.path)
-            query_params = urllib.parse.parse_qs(parsed_url.query)
-            if "code" in query_params and "state" in query_params:
-                code = query_params["code"][0]
-                state = query_params["state"][0]
-                self._logger.debug(f"\nReceived OAuth Callback:")
-                self._logger.debug(f"  code : {code}")
-                self._logger.debug(f"  state: {state}")
-                if state == self._oauth_state.state:
-                    self.send_response(200)
-                    self.send_header("Content-type", "text/html")
-                    self.end_headers()
-                    self.wfile.write(
-                        b"<html><body><h1>Authentication Successful!</h1><p>You can close this window.</p></body></html>"
-                    )
-                    self._on_success(code)
-                else:
-                    self._logger.error(f"Invalid state! Expected: {self._oauth_state.state}, Received: {state}")
-                    self.send_response(400)
-                    self.send_header("Content-type", "text/html")
-                    self.end_headers()
-                    self.wfile.write(b"<html><body><h1>Authentication Failed!</h1></body></html>")
-            else:
-                self._logger.debug(f"\nReceived Invalid OAuth Callback: {self.path}")
-                self.send_response(400)
-                self.send_header("Content-type", "text/html")
-                self.end_headers()
-                self.wfile.write(
-                    b"<html><body><h1>Authentication Failed!</h1><p>Invalid callback parameters.</p></body></html>"
-                )
-
-        def _stop_server(self):
-            self._oauth.stop_server()
-
-    @staticmethod
-    def _can_open_browser():
-        if platform.system() in ["Windows", "Darwin"]:
-            return True  # Assume GUI on Windows/Mac
-
-        if "DISPLAY" in os.environ and os.environ["DISPLAY"] != "":
-            return True  # X11 display available
-
-        return False
-
-    def _exchange_oauth_token(self, code: str, scopes: list[str], oauth_state: "KaggleOAuth.OAuthState"):
-        request = ExchangeOAuthTokenRequest()
-        request.code = code
-        request.code_verifier = oauth_state.code_verifier
-        request.grant_type = "authorization_code"
-
-        response = self._client.security.oauth_client.exchange_oauth_token(request)
-        self._creds = KaggleCredentials(
-            client=self._client,
-            refresh_token=response.refreshToken,
-            access_token=response.accessToken,
-            access_token_expiration=datetime.now(timezone.utc) + timedelta(seconds=response.expires_in),
-            username=response.username,
-            scopes=scopes,
-        )
-
-    def _run_oauth_flow(self, scopes: list[str], no_launch_browser: bool) -> KaggleCredentials:
-        use_browser = not no_launch_browser and KaggleOAuth._can_open_browser()
-        redirect_uri = self._http_client.get_oauth_default_redirect_url()
-        if use_browser:
-            port = random.randint(8000, 9000)
-            redirect_uri = f"http://localhost:{port}"
-            self._logger.debug(f"Will listen for the callback at: {redirect_uri}")
-
-        oauth_state = KaggleOAuth.OAuthState()
-        oauth_start_url = self._http_client.build_start_oauth_url(
-            client_id=KaggleOAuth.OAUTH_CLIENT_ID,
-            redirect_uri=redirect_uri,
-            scope=scopes,
-            state=oauth_state.state,
-            code_challenge=oauth_state.code_challenge,
-        )
-
-        if use_browser:
-            webbrowser.open(oauth_start_url)
-            print("Your browser has been opened to visit:")
-            print(f"  {oauth_start_url}\n\n")
-
-            def exchange_oauth_token(code: str):
-                self._exchange_oauth_token(code, scopes, oauth_state)
-
-            def handler_factory(*args, **kwargs):
-                return KaggleOAuth.OAuthCallbackHandler(
-                    *args,
-                    oauth=self,
-                    oauth_state=oauth_state,
-                    on_success=exchange_oauth_token,
-                    logger=self._logger,
-                    **kwargs,
-                )
-
-            self._server_running = True
-            with socketserver.TCPServer(("127.0.0.1", port), handler_factory) as httpd:
-                self._logger.debug(f"Listening for callback on port {port}...")
-                while self._server_running:
-                    httpd.handle_request()
-                self._logger.debug("OAuth flow completed (or server stopped).")
-        else:
-            print("\nGo to the following link in your browser, and complete the sign-in prompts at Kaggle:\n")
-            print(f"  {oauth_start_url}")
-            print(
-                "\nOnce finished, enter the verification code provided in your browser: ",
-                end="",
-            )
-            code = input()
-            self._exchange_oauth_token(code, scopes, oauth_state)
-
-        return self._creds
-
-    def stop_server(self):
-        self._server_running = False
-
-    def _ensure_creds_valid(self, creds: KaggleCredentials):
-        if not creds:
-            raise Exception("Authentication failed.")
-        return creds.introspect()
-
-    def authenticate(self, scopes: list[str], no_launch_browser: bool = False) -> KaggleCredentials:
-        creds = self._run_oauth_flow(scopes, no_launch_browser)
-        username = self._ensure_creds_valid(creds)
-        creds.save()
-        print(f"\nYou are now logged in as [{username}]\n")
-        return creds