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

kagglesdk/education/services/education_api_service.py

@@ -1,19 +0,0 @@
-from kagglesdk.education.types.education_api_service import ApiTrackExerciseInteractionRequest, ApiTrackExerciseInteractionResponse
-from kagglesdk.kaggle_http_client import KaggleHttpClient
-
-class EducationApiClient(object):
-
-  def __init__(self, client: KaggleHttpClient):
-    self._client = client
-
-  def track_exercise_interaction(self, request: ApiTrackExerciseInteractionRequest = None) -> ApiTrackExerciseInteractionResponse:
-    r"""
-    Args:
-      request (ApiTrackExerciseInteractionRequest):
-        The request object; initialized to empty instance if not specified.
-    """
-
-    if request is None:
-      request = ApiTrackExerciseInteractionRequest()
-
-    return self._client.call("education.EducationApiService", "TrackExerciseInteraction", request, ApiTrackExerciseInteractionResponse)

kagglesdk/education/types/education_api_service.py

@@ -1,248 +0,0 @@
-from kagglesdk.education.types.education_service import LearnExerciseInteractionType, LearnExerciseOutcomeType, LearnExerciseQuestionType, LearnNudge
-from kagglesdk.kaggle_object import *
-from typing import Optional
-
-class ApiTrackExerciseInteractionRequest(KaggleObject):
-  r"""
-  This is copied from TrackExerciseInteractionRequest in
-  education_service.proto, which will eventually be deprecated.  In the
-  meantime, make sure to keep these in sync.
-
-  NOTE: there's one small rename from `fork_parent_script_version_id` to
-  `fork_parent_kernel_session_id`.
-
-  Attributes:
-    exception_class (str)
-    failure_message (str)
-    interaction_type (LearnExerciseInteractionType)
-    learn_tools_version (str)
-    fork_parent_kernel_session_id (int)
-    outcome_type (LearnExerciseOutcomeType)
-    question_id (str)
-    question_type (LearnExerciseQuestionType)
-    trace (str)
-    value_towards_completion (float)
-  """
-
-  def __init__(self):
-    self._exception_class = ""
-    self._failure_message = ""
-    self._interaction_type = LearnExerciseInteractionType.LEARN_EXERCISE_INTERACTION_TYPE_UNSPECIFIED
-    self._learn_tools_version = ""
-    self._fork_parent_kernel_session_id = 0
-    self._outcome_type = LearnExerciseOutcomeType.LEARN_EXERCISE_OUTCOME_TYPE_UNSPECIFIED
-    self._question_id = ""
-    self._question_type = LearnExerciseQuestionType.LEARN_EXERCISE_QUESTION_TYPE_UNSPECIFIED
-    self._trace = ""
-    self._value_towards_completion = None
-    self._freeze()
-
-  @property
-  def exception_class(self) -> str:
-    return self._exception_class
-
-  @exception_class.setter
-  def exception_class(self, exception_class: str):
-    if exception_class is None:
-      del self.exception_class
-      return
-    if not isinstance(exception_class, str):
-      raise TypeError('exception_class must be of type str')
-    self._exception_class = exception_class
-
-  @property
-  def failure_message(self) -> str:
-    return self._failure_message
-
-  @failure_message.setter
-  def failure_message(self, failure_message: str):
-    if failure_message is None:
-      del self.failure_message
-      return
-    if not isinstance(failure_message, str):
-      raise TypeError('failure_message must be of type str')
-    self._failure_message = failure_message
-
-  @property
-  def interaction_type(self) -> 'LearnExerciseInteractionType':
-    return self._interaction_type
-
-  @interaction_type.setter
-  def interaction_type(self, interaction_type: 'LearnExerciseInteractionType'):
-    if interaction_type is None:
-      del self.interaction_type
-      return
-    if not isinstance(interaction_type, LearnExerciseInteractionType):
-      raise TypeError('interaction_type must be of type LearnExerciseInteractionType')
-    self._interaction_type = interaction_type
-
-  @property
-  def learn_tools_version(self) -> str:
-    return self._learn_tools_version
-
-  @learn_tools_version.setter
-  def learn_tools_version(self, learn_tools_version: str):
-    if learn_tools_version is None:
-      del self.learn_tools_version
-      return
-    if not isinstance(learn_tools_version, str):
-      raise TypeError('learn_tools_version must be of type str')
-    self._learn_tools_version = learn_tools_version
-
-  @property
-  def fork_parent_kernel_session_id(self) -> int:
-    return self._fork_parent_kernel_session_id
-
-  @fork_parent_kernel_session_id.setter
-  def fork_parent_kernel_session_id(self, fork_parent_kernel_session_id: int):
-    if fork_parent_kernel_session_id is None:
-      del self.fork_parent_kernel_session_id
-      return
-    if not isinstance(fork_parent_kernel_session_id, int):
-      raise TypeError('fork_parent_kernel_session_id must be of type int')
-    self._fork_parent_kernel_session_id = fork_parent_kernel_session_id
-
-  @property
-  def outcome_type(self) -> 'LearnExerciseOutcomeType':
-    return self._outcome_type
-
-  @outcome_type.setter
-  def outcome_type(self, outcome_type: 'LearnExerciseOutcomeType'):
-    if outcome_type is None:
-      del self.outcome_type
-      return
-    if not isinstance(outcome_type, LearnExerciseOutcomeType):
-      raise TypeError('outcome_type must be of type LearnExerciseOutcomeType')
-    self._outcome_type = outcome_type
-
-  @property
-  def question_id(self) -> str:
-    return self._question_id
-
-  @question_id.setter
-  def question_id(self, question_id: str):
-    if question_id is None:
-      del self.question_id
-      return
-    if not isinstance(question_id, str):
-      raise TypeError('question_id must be of type str')
-    self._question_id = question_id
-
-  @property
-  def question_type(self) -> 'LearnExerciseQuestionType':
-    return self._question_type
-
-  @question_type.setter
-  def question_type(self, question_type: 'LearnExerciseQuestionType'):
-    if question_type is None:
-      del self.question_type
-      return
-    if not isinstance(question_type, LearnExerciseQuestionType):
-      raise TypeError('question_type must be of type LearnExerciseQuestionType')
-    self._question_type = question_type
-
-  @property
-  def trace(self) -> str:
-    return self._trace
-
-  @trace.setter
-  def trace(self, trace: str):
-    if trace is None:
-      del self.trace
-      return
-    if not isinstance(trace, str):
-      raise TypeError('trace must be of type str')
-    self._trace = trace
-
-  @property
-  def value_towards_completion(self) -> float:
-    return self._value_towards_completion or 0.0
-
-  @value_towards_completion.setter
-  def value_towards_completion(self, value_towards_completion: Optional[float]):
-    if value_towards_completion is None:
-      del self.value_towards_completion
-      return
-    if not isinstance(value_towards_completion, float):
-      raise TypeError('value_towards_completion must be of type float')
-    self._value_towards_completion = value_towards_completion
-
-  def endpoint(self):
-    path = '/api/v1/learn/track'
-    return path.format_map(self.to_field_map(self))
-
-
-  @staticmethod
-  def method():
-    return 'POST'
-
-  @staticmethod
-  def body_fields():
-    return '*'
-
-
-class ApiTrackExerciseInteractionResponse(KaggleObject):
-  r"""
-  This is copied from TrackExerciseInteractionResponse in
-  education_service.proto, which will eventually be deprecated.  In the
-  meantime, make sure to keep these in sync.
-
-  Attributes:
-    nudge (LearnNudge)
-    show_login_prompt (bool)
-  """
-
-  def __init__(self):
-    self._nudge = None
-    self._show_login_prompt = False
-    self._freeze()
-
-  @property
-  def nudge(self) -> Optional['LearnNudge']:
-    return self._nudge
-
-  @nudge.setter
-  def nudge(self, nudge: Optional['LearnNudge']):
-    if nudge is None:
-      del self.nudge
-      return
-    if not isinstance(nudge, LearnNudge):
-      raise TypeError('nudge must be of type LearnNudge')
-    self._nudge = nudge
-
-  @property
-  def show_login_prompt(self) -> bool:
-    return self._show_login_prompt
-
-  @show_login_prompt.setter
-  def show_login_prompt(self, show_login_prompt: bool):
-    if show_login_prompt is None:
-      del self.show_login_prompt
-      return
-    if not isinstance(show_login_prompt, bool):
-      raise TypeError('show_login_prompt must be of type bool')
-    self._show_login_prompt = show_login_prompt
-
-  @property
-  def showLoginPrompt(self):
-    return self.show_login_prompt
-
-
-ApiTrackExerciseInteractionRequest._fields = [
-  FieldMetadata("exceptionClass", "exception_class", "_exception_class", str, "", PredefinedSerializer()),
-  FieldMetadata("failureMessage", "failure_message", "_failure_message", str, "", PredefinedSerializer()),
-  FieldMetadata("interactionType", "interaction_type", "_interaction_type", LearnExerciseInteractionType, LearnExerciseInteractionType.LEARN_EXERCISE_INTERACTION_TYPE_UNSPECIFIED, EnumSerializer()),
-  FieldMetadata("learnToolsVersion", "learn_tools_version", "_learn_tools_version", str, "", PredefinedSerializer()),
-  FieldMetadata("forkParentKernelSessionId", "fork_parent_kernel_session_id", "_fork_parent_kernel_session_id", int, 0, PredefinedSerializer()),
-  FieldMetadata("outcomeType", "outcome_type", "_outcome_type", LearnExerciseOutcomeType, LearnExerciseOutcomeType.LEARN_EXERCISE_OUTCOME_TYPE_UNSPECIFIED, EnumSerializer()),
-  FieldMetadata("questionId", "question_id", "_question_id", str, "", PredefinedSerializer()),
-  FieldMetadata("questionType", "question_type", "_question_type", LearnExerciseQuestionType, LearnExerciseQuestionType.LEARN_EXERCISE_QUESTION_TYPE_UNSPECIFIED, EnumSerializer()),
-  FieldMetadata("trace", "trace", "_trace", str, "", PredefinedSerializer()),
-  FieldMetadata("valueTowardsCompletion", "value_towards_completion", "_value_towards_completion", float, None, PredefinedSerializer(), optional=True),
-]
-
-ApiTrackExerciseInteractionResponse._fields = [
-  FieldMetadata("nudge", "nudge", "_nudge", LearnNudge, None, KaggleObjectSerializer()),
-  FieldMetadata("showLoginPrompt", "show_login_prompt", "_show_login_prompt", bool, False, PredefinedSerializer()),
-]
-

kagglesdk/education/types/education_service.py

@@ -1,139 +0,0 @@
-import enum
-from kagglesdk.kaggle_object import *
-from typing import Optional
-
-class LearnExerciseInteractionType(enum.Enum):
-  LEARN_EXERCISE_INTERACTION_TYPE_UNSPECIFIED = 0
-  CHECK = 1
-  HINT = 2
-  SOLUTION = 3
-
-class LearnExerciseOutcomeType(enum.Enum):
-  LEARN_EXERCISE_OUTCOME_TYPE_UNSPECIFIED = 0
-  PASS = 1
-  FAIL = 2
-  EXCEPTION = 3
-  UNATTEMPTED = 4
-
-class LearnExerciseQuestionType(enum.Enum):
-  LEARN_EXERCISE_QUESTION_TYPE_UNSPECIFIED = 0
-  EQUALITY_CHECK_PROBLEM = 1
-  CODING_PROBLEM = 2
-  FUNCTION_PROBLEM = 3
-  THOUGHT_EXPERIMENT = 4
-
-class LearnNudgeType(enum.Enum):
-  COURSE_COMPLETE_NO_BONUS_LESSONS = 0
-  COURSE_COMPLETE_WITH_BONUS_LESSONS = 1
-  COURSE_INCOMPLETE = 2
-  DO_EXERCISE = 3
-  DO_TUTORIAL = 4
-
-class LearnNudge(KaggleObject):
-  r"""
-  Attributes:
-    course_index (int)
-    course_name (str)
-    course_slug (str)
-    next_item_name (str)
-    next_item_url (str)
-    next_item_type (LearnNudgeType)
-  """
-
-  def __init__(self):
-    self._course_index = 0
-    self._course_name = ""
-    self._course_slug = ""
-    self._next_item_name = ""
-    self._next_item_url = ""
-    self._next_item_type = LearnNudgeType.COURSE_COMPLETE_NO_BONUS_LESSONS
-    self._freeze()
-
-  @property
-  def course_index(self) -> int:
-    return self._course_index
-
-  @course_index.setter
-  def course_index(self, course_index: int):
-    if course_index is None:
-      del self.course_index
-      return
-    if not isinstance(course_index, int):
-      raise TypeError('course_index must be of type int')
-    self._course_index = course_index
-
-  @property
-  def course_name(self) -> str:
-    return self._course_name
-
-  @course_name.setter
-  def course_name(self, course_name: str):
-    if course_name is None:
-      del self.course_name
-      return
-    if not isinstance(course_name, str):
-      raise TypeError('course_name must be of type str')
-    self._course_name = course_name
-
-  @property
-  def course_slug(self) -> str:
-    return self._course_slug
-
-  @course_slug.setter
-  def course_slug(self, course_slug: str):
-    if course_slug is None:
-      del self.course_slug
-      return
-    if not isinstance(course_slug, str):
-      raise TypeError('course_slug must be of type str')
-    self._course_slug = course_slug
-
-  @property
-  def next_item_name(self) -> str:
-    return self._next_item_name
-
-  @next_item_name.setter
-  def next_item_name(self, next_item_name: str):
-    if next_item_name is None:
-      del self.next_item_name
-      return
-    if not isinstance(next_item_name, str):
-      raise TypeError('next_item_name must be of type str')
-    self._next_item_name = next_item_name
-
-  @property
-  def next_item_url(self) -> str:
-    return self._next_item_url
-
-  @next_item_url.setter
-  def next_item_url(self, next_item_url: str):
-    if next_item_url is None:
-      del self.next_item_url
-      return
-    if not isinstance(next_item_url, str):
-      raise TypeError('next_item_url must be of type str')
-    self._next_item_url = next_item_url
-
-  @property
-  def next_item_type(self) -> 'LearnNudgeType':
-    return self._next_item_type
-
-  @next_item_type.setter
-  def next_item_type(self, next_item_type: 'LearnNudgeType'):
-    if next_item_type is None:
-      del self.next_item_type
-      return
-    if not isinstance(next_item_type, LearnNudgeType):
-      raise TypeError('next_item_type must be of type LearnNudgeType')
-    self._next_item_type = next_item_type
-
-
-LearnNudge._fields = [
-  FieldMetadata("courseIndex", "course_index", "_course_index", int, 0, PredefinedSerializer()),
-  FieldMetadata("courseName", "course_name", "_course_name", str, "", PredefinedSerializer()),
-  FieldMetadata("courseSlug", "course_slug", "_course_slug", str, "", PredefinedSerializer()),
-  FieldMetadata("nextItemName", "next_item_name", "_next_item_name", str, "", PredefinedSerializer()),
-  FieldMetadata("nextItemUrl", "next_item_url", "_next_item_url", str, "", PredefinedSerializer()),
-  FieldMetadata("nextItemType", "next_item_type", "_next_item_type", LearnNudgeType, LearnNudgeType.COURSE_COMPLETE_NO_BONUS_LESSONS, EnumSerializer()),
-]
-

kagglesdk/kaggle_client.py

@@ -1,101 +0,0 @@
-from kagglesdk.admin.services.inbox_file_service import InboxFileClient
-from kagglesdk.benchmarks.services.benchmarks_api_service import BenchmarksApiClient
-from kagglesdk.blobs.services.blob_api_service import BlobApiClient
-from kagglesdk.common.services.operations_service import OperationsClient
-from kagglesdk.competitions.services.competition_api_service import CompetitionApiClient
-from kagglesdk.datasets.services.dataset_api_service import DatasetApiClient
-from kagglesdk.education.services.education_api_service import EducationApiClient
-from kagglesdk.kernels.services.kernels_api_service import KernelsApiClient
-from kagglesdk.models.services.model_api_service import ModelApiClient
-from kagglesdk.models.services.model_service import ModelClient
-from kagglesdk.search.services.search_api_service import SearchApiClient
-from kagglesdk.security.services.iam_service import IamClient
-from kagglesdk.security.services.oauth_service import OAuthClient
-from kagglesdk.users.services.account_service import AccountClient
-from kagglesdk.users.services.group_api_service import GroupApiClient
-from kagglesdk.kaggle_env import KaggleEnv
-from kagglesdk.kaggle_http_client import KaggleHttpClient
-
-
-class KaggleClient(object):
-  class Admin(object):
-    def __init__(self, http_client: KaggleHttpClient):
-      self.inbox_file_client = InboxFileClient(http_client)
-
-  class Benchmarks(object):
-    def __init__(self, http_client: KaggleHttpClient):
-      self.benchmarks_api_client = BenchmarksApiClient(http_client)
-
-  class Blobs(object):
-    def __init__(self, http_client: KaggleHttpClient):
-      self.blob_api_client = BlobApiClient(http_client)
-
-  class Common(object):
-    def __init__(self, http_client: KaggleHttpClient):
-      self.operations_client = OperationsClient(http_client)
-
-  class Competitions(object):
-    def __init__(self, http_client: KaggleHttpClient):
-      self.competition_api_client = CompetitionApiClient(http_client)
-
-  class Datasets(object):
-    def __init__(self, http_client: KaggleHttpClient):
-      self.dataset_api_client = DatasetApiClient(http_client)
-
-  class Education(object):
-    def __init__(self, http_client: KaggleHttpClient):
-      self.education_api_client = EducationApiClient(http_client)
-
-  class Kernels(object):
-    def __init__(self, http_client: KaggleHttpClient):
-      self.kernels_api_client = KernelsApiClient(http_client)
-
-  class Models(object):
-    def __init__(self, http_client: KaggleHttpClient):
-      self.model_api_client = ModelApiClient(http_client)
-      self.model_client = ModelClient(http_client)
-
-  class Search(object):
-    def __init__(self, http_client: KaggleHttpClient):
-      self.search_api_client = SearchApiClient(http_client)
-
-  class Security(object):
-    def __init__(self, http_client: KaggleHttpClient):
-      self.iam_client = IamClient(http_client)
-      self.oauth_client = OAuthClient(http_client)
-
-  class Users(object):
-    def __init__(self, http_client: KaggleHttpClient):
-      self.account_client = AccountClient(http_client)
-      self.group_api_client = GroupApiClient(http_client)
-
-  def __init__(self, env: KaggleEnv = None, verbose: bool = False, username: str = None, password: str = None, api_token: str = None):
-    self._http_client = http_client = KaggleHttpClient(env, verbose, username=username, password=password, api_token=api_token)
-    self.admin = KaggleClient.Admin(http_client)
-    self.benchmarks = KaggleClient.Benchmarks(http_client)
-    self.blobs = KaggleClient.Blobs(http_client)
-    self.common = KaggleClient.Common(http_client)
-    self.competitions = KaggleClient.Competitions(http_client)
-    self.datasets = KaggleClient.Datasets(http_client)
-    self.education = KaggleClient.Education(http_client)
-    self.kernels = KaggleClient.Kernels(http_client)
-    self.models = KaggleClient.Models(http_client)
-    self.search = KaggleClient.Search(http_client)
-    self.security = KaggleClient.Security(http_client)
-    self.users = KaggleClient.Users(http_client)
-    self.username = username
-    self.password = password
-    self.api_token = api_token
-
-  def http_client(self) -> str:
-    return self._http_client
-
-  def _renew_iap_token(self) -> str:
-    return self.admin.admin_client.renew_iap_token()
-
-  def __enter__(self):
-    self._http_client.__enter__()
-    return self
-
-  def __exit__(self, exc_type, exc_value, tb):
-    self._http_client.__exit__(exc_type, exc_value, tb)

kagglesdk/kaggle_creds.py

@@ -1,148 +0,0 @@
-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