kaggle 1.7.3b1__py3-none-any.whl

kagglesdk/education/types/education_api_service.py

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

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

@@ -0,0 +1,66 @@
+from kagglesdk.kernels.services.kernels_api_service import KernelsApiClient
+from kagglesdk.blobs.services.blob_api_service import BlobApiClient
+from kagglesdk.education.services.education_api_service import EducationApiClient
+from kagglesdk.models.services.model_api_service import ModelApiClient
+from kagglesdk.models.services.model_service import ModelClient
+from kagglesdk.competitions.services.competition_api_service import CompetitionApiClient
+from kagglesdk.datasets.services.dataset_api_service import DatasetApiClient
+from kagglesdk.admin.services.inbox_file_service import InboxFileClient
+from kagglesdk.kaggle_env import KaggleEnv
+from kagglesdk.kaggle_http_client import KaggleHttpClient
+
+
+class KaggleClient(object):
+  class Kernels(object):
+    def __init__(self, http_client: KaggleHttpClient):
+      self.kernels_api_client = KernelsApiClient(http_client)
+
+  class Blobs(object):
+    def __init__(self, http_client: KaggleHttpClient):
+      self.blob_api_client = BlobApiClient(http_client)
+
+  class Education(object):
+    def __init__(self, http_client: KaggleHttpClient):
+      self.education_api_client = EducationApiClient(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 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 Admin(object):
+    def __init__(self, http_client: KaggleHttpClient):
+      self.inbox_file_client = InboxFileClient(http_client)
+
+  def __init__(self, env: KaggleEnv = None, verbose: bool = False, username: str = None, password: str = None):
+    self._http_client = http_client = KaggleHttpClient(env, verbose, self._renew_iap_token, username=username, password=password)
+    self.kernels = KaggleClient.Kernels(http_client)
+    self.blobs = KaggleClient.Blobs(http_client)
+    self.education = KaggleClient.Education(http_client)
+    self.models = KaggleClient.Models(http_client)
+    self.competitions = KaggleClient.Competitions(http_client)
+    self.datasets = KaggleClient.Datasets(http_client)
+    self.admin = KaggleClient.Admin(http_client)
+    self.username = username
+    self.password = password
+
+  def http_client(self):
+    return self._http_client
+
+  def _renew_iap_token(self):
+    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_env.py

@@ -0,0 +1,42 @@
+import os
+from enum import Enum
+
+
+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
+
+
+_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",
+}
+
+
+def get_endpoint(env: KaggleEnv):
+  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}"')