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

kagglesdk/kernels/types/kernels_api_service.py

@@ -1,8 +1,290 @@
 from datetime import datetime
 from kagglesdk.kaggle_object import *
-from kagglesdk.kernels.types.kernels_enums import KernelsListSortType, KernelsListViewType, KernelWorkerStatus
+from kagglesdk.kernels.types.kernels_enums import KernelExecutionType, KernelsListSortType, KernelsListViewType, KernelWorkerStatus
 from typing import Optional, List
 
+class ApiCancelKernelSessionRequest(KaggleObject):
+  r"""
+  Attributes:
+    kernel_session_id (int)
+  """
+
+  def __init__(self):
+    self._kernel_session_id = 0
+    self._freeze()
+
+  @property
+  def kernel_session_id(self) -> int:
+    return self._kernel_session_id
+
+  @kernel_session_id.setter
+  def kernel_session_id(self, kernel_session_id: int):
+    if kernel_session_id is None:
+      del self.kernel_session_id
+      return
+    if not isinstance(kernel_session_id, int):
+      raise TypeError('kernel_session_id must be of type int')
+    self._kernel_session_id = kernel_session_id
+
+  def endpoint(self):
+    path = '/api/v1/kernels/cancel-session/{kernel_session_id}'
+    return path.format_map(self.to_field_map(self))
+
+  @staticmethod
+  def endpoint_path():
+    return '/api/v1/kernels/cancel-session/{kernel_session_id}'
+
+
+class ApiCancelKernelSessionResponse(KaggleObject):
+  r"""
+  Attributes:
+    error_message (str)
+  """
+
+  def __init__(self):
+    self._error_message = None
+    self._freeze()
+
+  @property
+  def error_message(self) -> str:
+    return self._error_message or ""
+
+  @error_message.setter
+  def error_message(self, error_message: Optional[str]):
+    if error_message is None:
+      del self.error_message
+      return
+    if not isinstance(error_message, str):
+      raise TypeError('error_message must be of type str')
+    self._error_message = error_message
+
+  @property
+  def errorMessage(self):
+    return self.error_message
+
+
+class ApiCreateKernelSessionRequest(KaggleObject):
+  r"""
+  Attributes:
+    slug (str)
+      The full slug of the kernel to create an interactive session for, in the
+      format `{username}/{kernel-slug}`. The kernel slug must be the title
+      lowercased with dashes (`-`) replacing spaces.
+    language (str)
+      The language that the kernel is written in. One of 'python', 'r' and
+      'rmarkdown'.
+    kernel_type (str)
+      The type of kernel. Options are 'notebook' or 'script'.
+    docker_image (str)
+      Which docker image to run with. This must be one of the Kaggle-provided,
+      known images. It should look something like:
+      gcr.io/kaggle-images/python@sha256:f4b6dd72d4ac48c76fbb02bce0798b80b284102886ad37e6041e9ab721dc8873
+    machine_shape (str)
+      The machine shape to use for this session. Currently supported options:
+         * NvidiaTeslaT4
+         * NvidiaTeslaP100
+         * Tpu1VmV38
+    enable_internet (bool)
+      Whether or not the kernel should be able to access the internet in this
+      session.
+  """
+
+  def __init__(self):
+    self._slug = ""
+    self._language = None
+    self._kernel_type = None
+    self._docker_image = None
+    self._machine_shape = None
+    self._enable_internet = None
+    self._freeze()
+
+  @property
+  def slug(self) -> str:
+    r"""
+    The full slug of the kernel to create an interactive session for, in the
+    format `{username}/{kernel-slug}`. The kernel slug must be the title
+    lowercased with dashes (`-`) replacing spaces.
+    """
+    return self._slug
+
+  @slug.setter
+  def slug(self, slug: str):
+    if slug is None:
+      del self.slug
+      return
+    if not isinstance(slug, str):
+      raise TypeError('slug must be of type str')
+    self._slug = slug
+
+  @property
+  def language(self) -> str:
+    r"""
+    The language that the kernel is written in. One of 'python', 'r' and
+    'rmarkdown'.
+    """
+    return self._language or ""
+
+  @language.setter
+  def language(self, language: Optional[str]):
+    if language is None:
+      del self.language
+      return
+    if not isinstance(language, str):
+      raise TypeError('language must be of type str')
+    self._language = language
+
+  @property
+  def kernel_type(self) -> str:
+    """The type of kernel. Options are 'notebook' or 'script'."""
+    return self._kernel_type or ""
+
+  @kernel_type.setter
+  def kernel_type(self, kernel_type: Optional[str]):
+    if kernel_type is None:
+      del self.kernel_type
+      return
+    if not isinstance(kernel_type, str):
+      raise TypeError('kernel_type must be of type str')
+    self._kernel_type = kernel_type
+
+  @property
+  def docker_image(self) -> str:
+    r"""
+    Which docker image to run with. This must be one of the Kaggle-provided,
+    known images. It should look something like:
+    gcr.io/kaggle-images/python@sha256:f4b6dd72d4ac48c76fbb02bce0798b80b284102886ad37e6041e9ab721dc8873
+    """
+    return self._docker_image or ""
+
+  @docker_image.setter
+  def docker_image(self, docker_image: Optional[str]):
+    if docker_image is None:
+      del self.docker_image
+      return
+    if not isinstance(docker_image, str):
+      raise TypeError('docker_image must be of type str')
+    self._docker_image = docker_image
+
+  @property
+  def machine_shape(self) -> str:
+    r"""
+    The machine shape to use for this session. Currently supported options:
+       * NvidiaTeslaT4
+       * NvidiaTeslaP100
+       * Tpu1VmV38
+    """
+    return self._machine_shape or ""
+
+  @machine_shape.setter
+  def machine_shape(self, machine_shape: Optional[str]):
+    if machine_shape is None:
+      del self.machine_shape
+      return
+    if not isinstance(machine_shape, str):
+      raise TypeError('machine_shape must be of type str')
+    self._machine_shape = machine_shape
+
+  @property
+  def enable_internet(self) -> bool:
+    r"""
+    Whether or not the kernel should be able to access the internet in this
+    session.
+    """
+    return self._enable_internet or False
+
+  @enable_internet.setter
+  def enable_internet(self, enable_internet: Optional[bool]):
+    if enable_internet is None:
+      del self.enable_internet
+      return
+    if not isinstance(enable_internet, bool):
+      raise TypeError('enable_internet must be of type bool')
+    self._enable_internet = enable_internet
+
+  def endpoint(self):
+    path = '/api/v1/kernels/create-session/{slug}'
+    return path.format_map(self.to_field_map(self))
+
+  @staticmethod
+  def endpoint_path():
+    return '/api/v1/kernels/create-session/{slug}'
+
+
+class ApiDeleteKernelRequest(KaggleObject):
+  r"""
+  Attributes:
+    user_name (str)
+    kernel_slug (str)
+  """
+
+  def __init__(self):
+    self._user_name = ""
+    self._kernel_slug = ""
+    self._freeze()
+
+  @property
+  def user_name(self) -> str:
+    return self._user_name
+
+  @user_name.setter
+  def user_name(self, user_name: str):
+    if user_name is None:
+      del self.user_name
+      return
+    if not isinstance(user_name, str):
+      raise TypeError('user_name must be of type str')
+    self._user_name = user_name
+
+  @property
+  def kernel_slug(self) -> str:
+    return self._kernel_slug
+
+  @kernel_slug.setter
+  def kernel_slug(self, kernel_slug: str):
+    if kernel_slug is None:
+      del self.kernel_slug
+      return
+    if not isinstance(kernel_slug, str):
+      raise TypeError('kernel_slug must be of type str')
+    self._kernel_slug = kernel_slug
+
+  def endpoint(self):
+    path = '/api/v1/kernels/delete/{user_name}/{kernel_slug}'
+    return path.format_map(self.to_field_map(self))
+
+  @staticmethod
+  def endpoint_path():
+    return '/api/v1/kernels/delete/{user_name}/{kernel_slug}'
+
+
+class ApiDeleteKernelResponse(KaggleObject):
+  r"""
+  Attributes:
+    error_message (str)
+  """
+
+  def __init__(self):
+    self._error_message = None
+    self._freeze()
+
+  @property
+  def error_message(self) -> str:
+    return self._error_message or ""
+
+  @error_message.setter
+  def error_message(self, error_message: Optional[str]):
+    if error_message is None:
+      del self.error_message
+      return
+    if not isinstance(error_message, str):
+      raise TypeError('error_message must be of type str')
+    self._error_message = error_message
+
+  @property
+  def errorMessage(self):
+    return self.error_message
+
+
 class ApiDownloadKernelOutputRequest(KaggleObject):
   r"""
   Attributes:
@@ -52,7 +334,7 @@ class ApiDownloadKernelOutputRequest(KaggleObject):
     return self._file_path or ""
 
   @file_path.setter
-  def file_path(self, file_path: str):
+  def file_path(self, file_path: Optional[str]):
     if file_path is None:
       del self.file_path
       return
@@ -65,7 +347,7 @@ class ApiDownloadKernelOutputRequest(KaggleObject):
     return self._version_number or 0
 
   @version_number.setter
-  def version_number(self, version_number: int):
+  def version_number(self, version_number: Optional[int]):
     if version_number is None:
       del self.version_number
       return
@@ -272,7 +554,7 @@ class ApiGetKernelSessionStatusResponse(KaggleObject):
     return self._failure_message or ""
 
   @failure_message.setter
-  def failure_message(self, failure_message: str):
+  def failure_message(self, failure_message: Optional[str]):
     if failure_message is None:
       del self.failure_message
       return
@@ -306,7 +588,7 @@ class ApiKernelBlob(KaggleObject):
     return self._source or ""
 
   @source.setter
-  def source(self, source: str):
+  def source(self, source: Optional[str]):
     if source is None:
       del self.source
       return
@@ -319,7 +601,7 @@ class ApiKernelBlob(KaggleObject):
     return self._language or ""
 
   @language.setter
-  def language(self, language: str):
+  def language(self, language: Optional[str]):
     if language is None:
       del self.language
       return
@@ -332,7 +614,7 @@ class ApiKernelBlob(KaggleObject):
     return self._kernel_type or ""
 
   @kernel_type.setter
-  def kernel_type(self, kernel_type: str):
+  def kernel_type(self, kernel_type: Optional[str]):
     if kernel_type is None:
       del self.kernel_type
       return
@@ -345,7 +627,7 @@ class ApiKernelBlob(KaggleObject):
     return self._slug or ""
 
   @slug.setter
-  def slug(self, slug: str):
+  def slug(self, slug: Optional[str]):
     if slug is None:
       del self.slug
       return
@@ -367,15 +649,20 @@ class ApiKernelMetadata(KaggleObject):
     kernel_type (str)
     is_private (bool)
     enable_gpu (bool)
-    enable_tpu (bool)
     enable_internet (bool)
     category_ids (str)
     dataset_data_sources (str)
     kernel_data_sources (str)
     competition_data_sources (str)
-    model_data_sources (str)
     total_votes (int)
+    model_data_sources (str)
+    enable_tpu (bool)
     current_version_number (int)
+    docker_image (str)
+    machine_shape (str)
+      The machine shape that was used in the last session. Largely, this
+      indicates the type of accelerator, but it may include other attributes
+      about the hardware configuration.
   """
 
   def __init__(self):
@@ -389,15 +676,17 @@ class ApiKernelMetadata(KaggleObject):
     self._kernel_type = None
     self._is_private = None
     self._enable_gpu = None
-    self._enable_tpu = None
     self._enable_internet = None
     self._category_ids = []
     self._dataset_data_sources = []
     self._kernel_data_sources = []
     self._competition_data_sources = []
-    self._model_data_sources = []
     self._total_votes = 0
+    self._model_data_sources = []
+    self._enable_tpu = None
     self._current_version_number = None
+    self._docker_image = None
+    self._machine_shape = None
     self._freeze()
 
   @property
@@ -483,7 +772,7 @@ class ApiKernelMetadata(KaggleObject):
     return self._language or ""
 
   @language.setter
-  def language(self, language: str):
+  def language(self, language: Optional[str]):
     if language is None:
       del self.language
       return
@@ -496,7 +785,7 @@ class ApiKernelMetadata(KaggleObject):
     return self._kernel_type or ""
 
   @kernel_type.setter
-  def kernel_type(self, kernel_type: str):
+  def kernel_type(self, kernel_type: Optional[str]):
     if kernel_type is None:
       del self.kernel_type
       return
@@ -509,7 +798,7 @@ class ApiKernelMetadata(KaggleObject):
     return self._is_private or False
 
   @is_private.setter
-  def is_private(self, is_private: bool):
+  def is_private(self, is_private: Optional[bool]):
     if is_private is None:
       del self.is_private
       return
@@ -522,7 +811,7 @@ class ApiKernelMetadata(KaggleObject):
     return self._enable_gpu or False
 
   @enable_gpu.setter
-  def enable_gpu(self, enable_gpu: bool):
+  def enable_gpu(self, enable_gpu: Optional[bool]):
     if enable_gpu is None:
       del self.enable_gpu
       return
@@ -535,7 +824,7 @@ class ApiKernelMetadata(KaggleObject):
     return self._enable_tpu or False
 
   @enable_tpu.setter
-  def enable_tpu(self, enable_tpu: bool):
+  def enable_tpu(self, enable_tpu: Optional[bool]):
     if enable_tpu is None:
       del self.enable_tpu
       return
@@ -548,7 +837,7 @@ class ApiKernelMetadata(KaggleObject):
     return self._enable_internet or False
 
   @enable_internet.setter
-  def enable_internet(self, enable_internet: bool):
+  def enable_internet(self, enable_internet: Optional[bool]):
     if enable_internet is None:
       del self.enable_internet
       return
@@ -649,7 +938,7 @@ class ApiKernelMetadata(KaggleObject):
     return self._current_version_number or 0
 
   @current_version_number.setter
-  def current_version_number(self, current_version_number: int):
+  def current_version_number(self, current_version_number: Optional[int]):
     if current_version_number is None:
       del self.current_version_number
       return
@@ -657,6 +946,130 @@ class ApiKernelMetadata(KaggleObject):
       raise TypeError('current_version_number must be of type int')
     self._current_version_number = current_version_number
 
+  @property
+  def docker_image(self) -> str:
+    return self._docker_image or ""
+
+  @docker_image.setter
+  def docker_image(self, docker_image: Optional[str]):
+    if docker_image is None:
+      del self.docker_image
+      return
+    if not isinstance(docker_image, str):
+      raise TypeError('docker_image must be of type str')
+    self._docker_image = docker_image
+
+  @property
+  def machine_shape(self) -> str:
+    r"""
+    The machine shape that was used in the last session. Largely, this
+    indicates the type of accelerator, but it may include other attributes
+    about the hardware configuration.
+    """
+    return self._machine_shape or ""
+
+  @machine_shape.setter
+  def machine_shape(self, machine_shape: Optional[str]):
+    if machine_shape is None:
+      del self.machine_shape
+      return
+    if not isinstance(machine_shape, str):
+      raise TypeError('machine_shape must be of type str')
+    self._machine_shape = machine_shape
+
+
+class ApiKernelSessionOutputFile(KaggleObject):
+  r"""
+  Attributes:
+    url (str)
+    file_name (str)
+  """
+
+  def __init__(self):
+    self._url = None
+    self._file_name = None
+    self._freeze()
+
+  @property
+  def url(self) -> str:
+    return self._url or ""
+
+  @url.setter
+  def url(self, url: Optional[str]):
+    if url is None:
+      del self.url
+      return
+    if not isinstance(url, str):
+      raise TypeError('url must be of type str')
+    self._url = url
+
+  @property
+  def file_name(self) -> str:
+    return self._file_name or ""
+
+  @file_name.setter
+  def file_name(self, file_name: Optional[str]):
+    if file_name is None:
+      del self.file_name
+      return
+    if not isinstance(file_name, str):
+      raise TypeError('file_name must be of type str')
+    self._file_name = file_name
+
+
+class ApiListKernelFilesItem(KaggleObject):
+  r"""
+  Attributes:
+    name (str)
+    size (int)
+    creation_date (str)
+  """
+
+  def __init__(self):
+    self._name = ""
+    self._size = 0
+    self._creation_date = ""
+    self._freeze()
+
+  @property
+  def name(self) -> str:
+    return self._name
+
+  @name.setter
+  def name(self, name: str):
+    if name is None:
+      del self.name
+      return
+    if not isinstance(name, str):
+      raise TypeError('name must be of type str')
+    self._name = name
+
+  @property
+  def size(self) -> int:
+    return self._size
+
+  @size.setter
+  def size(self, size: int):
+    if size is None:
+      del self.size
+      return
+    if not isinstance(size, int):
+      raise TypeError('size must be of type int')
+    self._size = size
+
+  @property
+  def creation_date(self) -> str:
+    return self._creation_date
+
+  @creation_date.setter
+  def creation_date(self, creation_date: str):
+    if creation_date is None:
+      del self.creation_date
+      return
+    if not isinstance(creation_date, str):
+      raise TypeError('creation_date must be of type str')
+    self._creation_date = creation_date
+
 
 class ApiListKernelFilesRequest(KaggleObject):
   r"""
@@ -705,7 +1118,7 @@ class ApiListKernelFilesRequest(KaggleObject):
     return self._page_size or 0
 
   @page_size.setter
-  def page_size(self, page_size: int):
+  def page_size(self, page_size: Optional[int]):
     if page_size is None:
       del self.page_size
       return
@@ -718,7 +1131,7 @@ class ApiListKernelFilesRequest(KaggleObject):
     return self._page_token or ""
 
   @page_token.setter
-  def page_token(self, page_token: str):
+  def page_token(self, page_token: Optional[str]):
     if page_token is None:
       del self.page_token
       return
@@ -763,7 +1176,7 @@ class ApiListKernelFilesResponse(KaggleObject):
     return self._next_page_token or ""
 
   @next_page_token.setter
-  def next_page_token(self, next_page_token: str):
+  def next_page_token(self, next_page_token: Optional[str]):
     if next_page_token is None:
       del self.next_page_token
       return
@@ -823,7 +1236,7 @@ class ApiListKernelSessionOutputRequest(KaggleObject):
     return self._page_size or 0
 
   @page_size.setter
-  def page_size(self, page_size: int):
+  def page_size(self, page_size: Optional[int]):
     if page_size is None:
       del self.page_size
       return
@@ -836,7 +1249,7 @@ class ApiListKernelSessionOutputRequest(KaggleObject):
     return self._page_token or ""
 
   @page_token.setter
-  def page_token(self, page_token: str):
+  def page_token(self, page_token: Optional[str]):
     if page_token is None:
       del self.page_token
       return
@@ -883,7 +1296,7 @@ class ApiListKernelSessionOutputResponse(KaggleObject):
     return self._log or ""
 
   @log.setter
-  def log(self, log: str):
+  def log(self, log: Optional[str]):
     if log is None:
       del self.log
       return
@@ -896,7 +1309,7 @@ class ApiListKernelSessionOutputResponse(KaggleObject):
     return self._next_page_token or ""
 
   @next_page_token.setter
-  def next_page_token(self, next_page_token: str):
+  def next_page_token(self, next_page_token: Optional[str]):
     if next_page_token is None:
       del self.next_page_token
       return
@@ -939,6 +1352,7 @@ class ApiListKernelsRequest(KaggleObject):
       Page number (default is 1).
     page_size (int)
       Page size, i.e., maximum number of results to return.
+    page_token (str)
   """
 
   def __init__(self):
@@ -954,6 +1368,7 @@ class ApiListKernelsRequest(KaggleObject):
     self._user = None
     self._page = None
     self._page_size = None
+    self._page_token = None
     self._freeze()
 
   @property
@@ -962,7 +1377,7 @@ class ApiListKernelsRequest(KaggleObject):
     return self._competition or ""
 
   @competition.setter
-  def competition(self, competition: str):
+  def competition(self, competition: Optional[str]):
     if competition is None:
       del self.competition
       return
@@ -976,7 +1391,7 @@ class ApiListKernelsRequest(KaggleObject):
     return self._dataset or ""
 
   @dataset.setter
-  def dataset(self, dataset: str):
+  def dataset(self, dataset: Optional[str]):
     if dataset is None:
       del self.dataset
       return
@@ -990,7 +1405,7 @@ class ApiListKernelsRequest(KaggleObject):
     return self._parent_kernel or ""
 
   @parent_kernel.setter
-  def parent_kernel(self, parent_kernel: str):
+  def parent_kernel(self, parent_kernel: Optional[str]):
     if parent_kernel is None:
       del self.parent_kernel
       return
@@ -1018,7 +1433,7 @@ class ApiListKernelsRequest(KaggleObject):
     return self._kernel_type or ""
 
   @kernel_type.setter
-  def kernel_type(self, kernel_type: str):
+  def kernel_type(self, kernel_type: Optional[str]):
     if kernel_type is None:
       del self.kernel_type
       return
@@ -1035,7 +1450,7 @@ class ApiListKernelsRequest(KaggleObject):
     return self._language or ""
 
   @language.setter
-  def language(self, language: str):
+  def language(self, language: Optional[str]):
     if language is None:
       del self.language
       return
@@ -1052,7 +1467,7 @@ class ApiListKernelsRequest(KaggleObject):
     return self._output_type or ""
 
   @output_type.setter
-  def output_type(self, output_type: str):
+  def output_type(self, output_type: Optional[str]):
     if output_type is None:
       del self.output_type
       return
@@ -1066,7 +1481,7 @@ class ApiListKernelsRequest(KaggleObject):
     return self._search or ""
 
   @search.setter
-  def search(self, search: str):
+  def search(self, search: Optional[str]):
     if search is None:
       del self.search
       return
@@ -1097,7 +1512,7 @@ class ApiListKernelsRequest(KaggleObject):
     return self._user or ""
 
   @user.setter
-  def user(self, user: str):
+  def user(self, user: Optional[str]):
     if user is None:
       del self.user
       return
@@ -1111,7 +1526,7 @@ class ApiListKernelsRequest(KaggleObject):
     return self._page or 0
 
   @page.setter
-  def page(self, page: int):
+  def page(self, page: Optional[int]):
     if page is None:
       del self.page
       return
@@ -1125,7 +1540,7 @@ class ApiListKernelsRequest(KaggleObject):
     return self._page_size or 0
 
   @page_size.setter
-  def page_size(self, page_size: int):
+  def page_size(self, page_size: Optional[int]):
     if page_size is None:
       del self.page_size
       return
@@ -1133,6 +1548,19 @@ class ApiListKernelsRequest(KaggleObject):
       raise TypeError('page_size must be of type int')
     self._page_size = page_size
 
+  @property
+  def page_token(self) -> str:
+    return self._page_token or ""
+
+  @page_token.setter
+  def page_token(self, page_token: Optional[str]):
+    if page_token is None:
+      del self.page_token
+      return
+    if not isinstance(page_token, str):
+      raise TypeError('page_token must be of type str')
+    self._page_token = page_token
+
   def endpoint(self):
     path = '/api/v1/kernels/list'
     return path.format_map(self.to_field_map(self))
@@ -1142,10 +1570,12 @@ class ApiListKernelsResponse(KaggleObject):
   r"""
   Attributes:
     kernels (ApiKernelMetadata)
+    next_page_token (str)
   """
 
   def __init__(self):
     self._kernels = []
+    self._next_page_token = ""
     self._freeze()
 
   @property
@@ -1163,9 +1593,22 @@ class ApiListKernelsResponse(KaggleObject):
       raise TypeError('kernels must contain only items of type ApiKernelMetadata')
     self._kernels = kernels
 
-  @classmethod
-  def prepare_from(cls, http_response):
-    return cls.from_dict({'kernels': json.loads(http_response.text)})
+  @property
+  def next_page_token(self) -> str:
+    return self._next_page_token
+
+  @next_page_token.setter
+  def next_page_token(self, next_page_token: str):
+    if next_page_token is None:
+      del self.next_page_token
+      return
+    if not isinstance(next_page_token, str):
+      raise TypeError('next_page_token must be of type str')
+    self._next_page_token = next_page_token
+
+  @property
+  def nextPageToken(self):
+    return self.next_page_token
 
 
 class ApiSaveKernelRequest(KaggleObject):
@@ -1204,8 +1647,7 @@ class ApiSaveKernelRequest(KaggleObject):
       Whether or not the kernel should be private.
     enable_gpu (bool)
       Whether or not the kernel should run on a GPU.
-    enable_tpu (bool)
-      Whether or not the kernel should run on a TPU.
+      DEPRECATED: use `machine_shape` instead
     enable_internet (bool)
       Whether or not the kernel should be able to access the internet.
     docker_image_pinning_type (str)
@@ -1216,9 +1658,27 @@ class ApiSaveKernelRequest(KaggleObject):
       `{username}/{model-slug}/{framework}/{variation-slug}`
       Or versioned:
       `{username}/{model-slug}/{framework}/{variation-slug}/{version-number}`
+    enable_tpu (bool)
+      Whether or not the kernel should run on a TPU.
+      DEPRECATED: use `machine_shape` instead
     session_timeout_seconds (int)
       If specified, terminate the kernel session after this many seconds of
       runtime, which must be lower than the global maximum.
+    priority (int)
+      Sets the execution priority of this kernel session request when queued,
+      lower is better (10 will get run before 100).
+      Only allowed or certain clients.
+    docker_image (str)
+      Which docker image to run with. This must be one of the Kaggle-provided,
+      known images. It should look something like:
+      gcr.io/kaggle-images/python@sha256:f4b6dd72d4ac48c76fbb02bce0798b80b284102886ad37e6041e9ab721dc8873
+    kernel_execution_type (KernelExecutionType)
+      Which kernel version type to use.
+    machine_shape (str)
+      The machine shape to use for this session. Currently supported options:
+         * NvidiaTeslaT4
+         * NvidiaTeslaP100
+         * Tpu1VmV38
   """
 
   def __init__(self):
@@ -1234,11 +1694,15 @@ class ApiSaveKernelRequest(KaggleObject):
     self._category_ids = []
     self._is_private = None
     self._enable_gpu = None
-    self._enable_tpu = None
     self._enable_internet = None
     self._docker_image_pinning_type = None
     self._model_data_sources = []
+    self._enable_tpu = None
     self._session_timeout_seconds = None
+    self._priority = None
+    self._docker_image = None
+    self._kernel_execution_type = None
+    self._machine_shape = None
     self._freeze()
 
   @property
@@ -1250,7 +1714,7 @@ class ApiSaveKernelRequest(KaggleObject):
     return self._id or 0
 
   @id.setter
-  def id(self, id: int):
+  def id(self, id: Optional[int]):
     if id is None:
       del self.id
       return
@@ -1269,7 +1733,7 @@ class ApiSaveKernelRequest(KaggleObject):
     return self._slug or ""
 
   @slug.setter
-  def slug(self, slug: str):
+  def slug(self, slug: Optional[str]):
     if slug is None:
       del self.slug
       return
@@ -1283,7 +1747,7 @@ class ApiSaveKernelRequest(KaggleObject):
     return self._new_title or ""
 
   @new_title.setter
-  def new_title(self, new_title: str):
+  def new_title(self, new_title: Optional[str]):
     if new_title is None:
       del self.new_title
       return
@@ -1297,7 +1761,7 @@ class ApiSaveKernelRequest(KaggleObject):
     return self._text or ""
 
   @text.setter
-  def text(self, text: str):
+  def text(self, text: Optional[str]):
     if text is None:
       del self.text
       return
@@ -1314,7 +1778,7 @@ class ApiSaveKernelRequest(KaggleObject):
     return self._language or ""
 
   @language.setter
-  def language(self, language: str):
+  def language(self, language: Optional[str]):
     if language is None:
       del self.language
       return
@@ -1328,7 +1792,7 @@ class ApiSaveKernelRequest(KaggleObject):
     return self._kernel_type or ""
 
   @kernel_type.setter
-  def kernel_type(self, kernel_type: str):
+  def kernel_type(self, kernel_type: Optional[str]):
     if kernel_type is None:
       del self.kernel_type
       return
@@ -1414,7 +1878,7 @@ class ApiSaveKernelRequest(KaggleObject):
     return self._is_private or False
 
   @is_private.setter
-  def is_private(self, is_private: bool):
+  def is_private(self, is_private: Optional[bool]):
     if is_private is None:
       del self.is_private
       return
@@ -1424,11 +1888,14 @@ class ApiSaveKernelRequest(KaggleObject):
 
   @property
   def enable_gpu(self) -> bool:
-    """Whether or not the kernel should run on a GPU."""
+    r"""
+    Whether or not the kernel should run on a GPU.
+    DEPRECATED: use `machine_shape` instead
+    """
     return self._enable_gpu or False
 
   @enable_gpu.setter
-  def enable_gpu(self, enable_gpu: bool):
+  def enable_gpu(self, enable_gpu: Optional[bool]):
     if enable_gpu is None:
       del self.enable_gpu
       return
@@ -1438,11 +1905,14 @@ class ApiSaveKernelRequest(KaggleObject):
 
   @property
   def enable_tpu(self) -> bool:
-    """Whether or not the kernel should run on a TPU."""
+    r"""
+    Whether or not the kernel should run on a TPU.
+    DEPRECATED: use `machine_shape` instead
+    """
     return self._enable_tpu or False
 
   @enable_tpu.setter
-  def enable_tpu(self, enable_tpu: bool):
+  def enable_tpu(self, enable_tpu: Optional[bool]):
     if enable_tpu is None:
       del self.enable_tpu
       return
@@ -1456,7 +1926,7 @@ class ApiSaveKernelRequest(KaggleObject):
     return self._enable_internet or False
 
   @enable_internet.setter
-  def enable_internet(self, enable_internet: bool):
+  def enable_internet(self, enable_internet: Optional[bool]):
     if enable_internet is None:
       del self.enable_internet
       return
@@ -1470,7 +1940,7 @@ class ApiSaveKernelRequest(KaggleObject):
     return self._docker_image_pinning_type or ""
 
   @docker_image_pinning_type.setter
-  def docker_image_pinning_type(self, docker_image_pinning_type: str):
+  def docker_image_pinning_type(self, docker_image_pinning_type: Optional[str]):
     if docker_image_pinning_type is None:
       del self.docker_image_pinning_type
       return
@@ -1509,7 +1979,7 @@ class ApiSaveKernelRequest(KaggleObject):
     return self._session_timeout_seconds or 0
 
   @session_timeout_seconds.setter
-  def session_timeout_seconds(self, session_timeout_seconds: int):
+  def session_timeout_seconds(self, session_timeout_seconds: Optional[int]):
     if session_timeout_seconds is None:
       del self.session_timeout_seconds
       return
@@ -1517,6 +1987,75 @@ class ApiSaveKernelRequest(KaggleObject):
       raise TypeError('session_timeout_seconds must be of type int')
     self._session_timeout_seconds = session_timeout_seconds
 
+  @property
+  def priority(self) -> int:
+    r"""
+    Sets the execution priority of this kernel session request when queued,
+    lower is better (10 will get run before 100).
+    Only allowed or certain clients.
+    """
+    return self._priority or 0
+
+  @priority.setter
+  def priority(self, priority: Optional[int]):
+    if priority is None:
+      del self.priority
+      return
+    if not isinstance(priority, int):
+      raise TypeError('priority must be of type int')
+    self._priority = priority
+
+  @property
+  def docker_image(self) -> str:
+    r"""
+    Which docker image to run with. This must be one of the Kaggle-provided,
+    known images. It should look something like:
+    gcr.io/kaggle-images/python@sha256:f4b6dd72d4ac48c76fbb02bce0798b80b284102886ad37e6041e9ab721dc8873
+    """
+    return self._docker_image or ""
+
+  @docker_image.setter
+  def docker_image(self, docker_image: Optional[str]):
+    if docker_image is None:
+      del self.docker_image
+      return
+    if not isinstance(docker_image, str):
+      raise TypeError('docker_image must be of type str')
+    self._docker_image = docker_image
+
+  @property
+  def kernel_execution_type(self) -> 'KernelExecutionType':
+    """Which kernel version type to use."""
+    return self._kernel_execution_type or KernelExecutionType.KERNEL_EXECUTION_TYPE_UNSPECIFIED
+
+  @kernel_execution_type.setter
+  def kernel_execution_type(self, kernel_execution_type: Optional['KernelExecutionType']):
+    if kernel_execution_type is None:
+      del self.kernel_execution_type
+      return
+    if not isinstance(kernel_execution_type, KernelExecutionType):
+      raise TypeError('kernel_execution_type must be of type KernelExecutionType')
+    self._kernel_execution_type = kernel_execution_type
+
+  @property
+  def machine_shape(self) -> str:
+    r"""
+    The machine shape to use for this session. Currently supported options:
+       * NvidiaTeslaT4
+       * NvidiaTeslaP100
+       * Tpu1VmV38
+    """
+    return self._machine_shape or ""
+
+  @machine_shape.setter
+  def machine_shape(self, machine_shape: Optional[str]):
+    if machine_shape is None:
+      del self.machine_shape
+      return
+    if not isinstance(machine_shape, str):
+      raise TypeError('machine_shape must be of type str')
+    self._machine_shape = machine_shape
+
   def endpoint(self):
     path = '/api/v1/kernels/push'
     return path.format_map(self.to_field_map(self))
@@ -1543,6 +2082,7 @@ class ApiSaveKernelResponse(KaggleObject):
     invalid_competition_sources (str)
     invalid_kernel_sources (str)
     invalid_model_sources (str)
+    kernel_id (int)
   """
 
   def __init__(self):
@@ -1555,6 +2095,7 @@ class ApiSaveKernelResponse(KaggleObject):
     self._invalid_competition_sources = []
     self._invalid_kernel_sources = []
     self._invalid_model_sources = []
+    self._kernel_id = 0
     self._freeze()
 
   @property
@@ -1588,7 +2129,7 @@ class ApiSaveKernelResponse(KaggleObject):
     return self._version_number or 0
 
   @version_number.setter
-  def version_number(self, version_number: int):
+  def version_number(self, version_number: Optional[int]):
     if version_number is None:
       del self.version_number
       return
@@ -1601,7 +2142,7 @@ class ApiSaveKernelResponse(KaggleObject):
     return self._error or ""
 
   @error.setter
-  def error(self, error: str):
+  def error(self, error: Optional[str]):
     if error is None:
       del self.error
       return
@@ -1684,6 +2225,19 @@ class ApiSaveKernelResponse(KaggleObject):
       raise TypeError('invalid_model_sources must contain only items of type str')
     self._invalid_model_sources = invalid_model_sources
 
+  @property
+  def kernel_id(self) -> int:
+    return self._kernel_id
+
+  @kernel_id.setter
+  def kernel_id(self, kernel_id: int):
+    if kernel_id is None:
+      del self.kernel_id
+      return
+    if not isinstance(kernel_id, int):
+      raise TypeError('kernel_id must be of type int')
+    self._kernel_id = kernel_id
+
   @property
   def versionNumber(self):
     return self.version_number
@@ -1708,99 +2262,36 @@ class ApiSaveKernelResponse(KaggleObject):
   def invalidModelSources(self):
     return self.invalid_model_sources
 
-
-class ApiKernelSessionOutputFile(KaggleObject):
-  r"""
-  Attributes:
-    url (str)
-    file_name (str)
-  """
-
-  def __init__(self):
-    self._url = None
-    self._file_name = None
-    self._freeze()
-
   @property
-  def url(self) -> str:
-    return self._url or ""
-
-  @url.setter
-  def url(self, url: str):
-    if url is None:
-      del self.url
-      return
-    if not isinstance(url, str):
-      raise TypeError('url must be of type str')
-    self._url = url
+  def kernelId(self):
+    return self.kernel_id
 
-  @property
-  def file_name(self) -> str:
-    return self._file_name or ""
 
-  @file_name.setter
-  def file_name(self, file_name: str):
-    if file_name is None:
-      del self.file_name
-      return
-    if not isinstance(file_name, str):
-      raise TypeError('file_name must be of type str')
-    self._file_name = file_name
-
-
-class ApiListKernelFilesItem(KaggleObject):
-  r"""
-  Attributes:
-    name (str)
-    size (int)
-    creation_date (str)
-  """
-
-  def __init__(self):
-    self._name = ""
-    self._size = 0
-    self._creation_date = ""
-    self._freeze()
-
-  @property
-  def name(self) -> str:
-    return self._name
-
-  @name.setter
-  def name(self, name: str):
-    if name is None:
-      del self.name
-      return
-    if not isinstance(name, str):
-      raise TypeError('name must be of type str')
-    self._name = name
-
-  @property
-  def size(self) -> int:
-    return self._size
+ApiCancelKernelSessionRequest._fields = [
+  FieldMetadata("kernelSessionId", "kernel_session_id", "_kernel_session_id", int, 0, PredefinedSerializer()),
+]
 
-  @size.setter
-  def size(self, size: int):
-    if size is None:
-      del self.size
-      return
-    if not isinstance(size, int):
-      raise TypeError('size must be of type int')
-    self._size = size
+ApiCancelKernelSessionResponse._fields = [
+  FieldMetadata("errorMessage", "error_message", "_error_message", str, None, PredefinedSerializer(), optional=True),
+]
 
-  @property
-  def creation_date(self) -> str:
-    return self._creation_date
+ApiCreateKernelSessionRequest._fields = [
+  FieldMetadata("slug", "slug", "_slug", str, "", PredefinedSerializer()),
+  FieldMetadata("language", "language", "_language", str, None, PredefinedSerializer(), optional=True),
+  FieldMetadata("kernelType", "kernel_type", "_kernel_type", str, None, PredefinedSerializer(), optional=True),
+  FieldMetadata("dockerImage", "docker_image", "_docker_image", str, None, PredefinedSerializer(), optional=True),
+  FieldMetadata("machineShape", "machine_shape", "_machine_shape", str, None, PredefinedSerializer(), optional=True),
+  FieldMetadata("enableInternet", "enable_internet", "_enable_internet", bool, None, PredefinedSerializer(), optional=True),
+]
 
-  @creation_date.setter
-  def creation_date(self, creation_date: str):
-    if creation_date is None:
-      del self.creation_date
-      return
-    if not isinstance(creation_date, str):
-      raise TypeError('creation_date must be of type str')
-    self._creation_date = creation_date
+ApiDeleteKernelRequest._fields = [
+  FieldMetadata("userName", "user_name", "_user_name", str, "", PredefinedSerializer()),
+  FieldMetadata("kernelSlug", "kernel_slug", "_kernel_slug", str, "", PredefinedSerializer()),
+]
 
+ApiDeleteKernelResponse._fields = [
+  FieldMetadata("errorMessage", "error_message", "_error_message", str, None, PredefinedSerializer(), optional=True),
+]
 
 ApiDownloadKernelOutputRequest._fields = [
   FieldMetadata("ownerSlug", "owner_slug", "_owner_slug", str, "", PredefinedSerializer()),
@@ -1851,15 +2342,28 @@ ApiKernelMetadata._fields = [
   FieldMetadata("kernelType", "kernel_type", "_kernel_type", str, None, PredefinedSerializer(), optional=True),
   FieldMetadata("isPrivate", "is_private", "_is_private", bool, None, PredefinedSerializer(), optional=True),
   FieldMetadata("enableGpu", "enable_gpu", "_enable_gpu", bool, None, PredefinedSerializer(), optional=True),
-  FieldMetadata("enableTpu", "enable_tpu", "_enable_tpu", bool, None, PredefinedSerializer(), optional=True),
   FieldMetadata("enableInternet", "enable_internet", "_enable_internet", bool, None, PredefinedSerializer(), optional=True),
   FieldMetadata("categoryIds", "category_ids", "_category_ids", str, [], ListSerializer(PredefinedSerializer())),
   FieldMetadata("datasetDataSources", "dataset_data_sources", "_dataset_data_sources", str, [], ListSerializer(PredefinedSerializer())),
   FieldMetadata("kernelDataSources", "kernel_data_sources", "_kernel_data_sources", str, [], ListSerializer(PredefinedSerializer())),
   FieldMetadata("competitionDataSources", "competition_data_sources", "_competition_data_sources", str, [], ListSerializer(PredefinedSerializer())),
-  FieldMetadata("modelDataSources", "model_data_sources", "_model_data_sources", str, [], ListSerializer(PredefinedSerializer())),
   FieldMetadata("totalVotes", "total_votes", "_total_votes", int, 0, PredefinedSerializer()),
+  FieldMetadata("modelDataSources", "model_data_sources", "_model_data_sources", str, [], ListSerializer(PredefinedSerializer())),
+  FieldMetadata("enableTpu", "enable_tpu", "_enable_tpu", bool, None, PredefinedSerializer(), optional=True),
   FieldMetadata("currentVersionNumber", "current_version_number", "_current_version_number", int, None, PredefinedSerializer(), optional=True),
+  FieldMetadata("dockerImage", "docker_image", "_docker_image", str, None, PredefinedSerializer(), optional=True),
+  FieldMetadata("machineShape", "machine_shape", "_machine_shape", str, None, PredefinedSerializer(), optional=True),
+]
+
+ApiKernelSessionOutputFile._fields = [
+  FieldMetadata("url", "url", "_url", str, None, PredefinedSerializer(), optional=True),
+  FieldMetadata("fileName", "file_name", "_file_name", str, None, PredefinedSerializer(), optional=True),
+]
+
+ApiListKernelFilesItem._fields = [
+  FieldMetadata("name", "name", "_name", str, "", PredefinedSerializer()),
+  FieldMetadata("size", "size", "_size", int, 0, PredefinedSerializer()),
+  FieldMetadata("creationDate", "creation_date", "_creation_date", str, "", PredefinedSerializer()),
 ]
 
 ApiListKernelFilesRequest._fields = [
@@ -1900,10 +2404,12 @@ ApiListKernelsRequest._fields = [
   FieldMetadata("user", "user", "_user", str, None, PredefinedSerializer(), optional=True),
   FieldMetadata("page", "page", "_page", int, None, PredefinedSerializer(), optional=True),
   FieldMetadata("pageSize", "page_size", "_page_size", int, None, PredefinedSerializer(), optional=True),
+  FieldMetadata("pageToken", "page_token", "_page_token", str, None, PredefinedSerializer(), optional=True),
 ]
 
 ApiListKernelsResponse._fields = [
   FieldMetadata("kernels", "kernels", "_kernels", ApiKernelMetadata, [], ListSerializer(KaggleObjectSerializer())),
+  FieldMetadata("nextPageToken", "next_page_token", "_next_page_token", str, "", PredefinedSerializer()),
 ]
 
 ApiSaveKernelRequest._fields = [
@@ -1919,11 +2425,15 @@ ApiSaveKernelRequest._fields = [
   FieldMetadata("categoryIds", "category_ids", "_category_ids", str, [], ListSerializer(PredefinedSerializer())),
   FieldMetadata("isPrivate", "is_private", "_is_private", bool, None, PredefinedSerializer(), optional=True),
   FieldMetadata("enableGpu", "enable_gpu", "_enable_gpu", bool, None, PredefinedSerializer(), optional=True),
-  FieldMetadata("enableTpu", "enable_tpu", "_enable_tpu", bool, None, PredefinedSerializer(), optional=True),
   FieldMetadata("enableInternet", "enable_internet", "_enable_internet", bool, None, PredefinedSerializer(), optional=True),
   FieldMetadata("dockerImagePinningType", "docker_image_pinning_type", "_docker_image_pinning_type", str, None, PredefinedSerializer(), optional=True),
   FieldMetadata("modelDataSources", "model_data_sources", "_model_data_sources", str, [], ListSerializer(PredefinedSerializer())),
+  FieldMetadata("enableTpu", "enable_tpu", "_enable_tpu", bool, None, PredefinedSerializer(), optional=True),
   FieldMetadata("sessionTimeoutSeconds", "session_timeout_seconds", "_session_timeout_seconds", int, None, PredefinedSerializer(), optional=True),
+  FieldMetadata("priority", "priority", "_priority", int, None, PredefinedSerializer(), optional=True),
+  FieldMetadata("dockerImage", "docker_image", "_docker_image", str, None, PredefinedSerializer(), optional=True),
+  FieldMetadata("kernelExecutionType", "kernel_execution_type", "_kernel_execution_type", KernelExecutionType, None, EnumSerializer(), optional=True),
+  FieldMetadata("machineShape", "machine_shape", "_machine_shape", str, None, PredefinedSerializer(), optional=True),
 ]
 
 ApiSaveKernelResponse._fields = [
@@ -1936,16 +2446,6 @@ ApiSaveKernelResponse._fields = [
   FieldMetadata("invalidCompetitionSources", "invalid_competition_sources", "_invalid_competition_sources", str, [], ListSerializer(PredefinedSerializer())),
   FieldMetadata("invalidKernelSources", "invalid_kernel_sources", "_invalid_kernel_sources", str, [], ListSerializer(PredefinedSerializer())),
   FieldMetadata("invalidModelSources", "invalid_model_sources", "_invalid_model_sources", str, [], ListSerializer(PredefinedSerializer())),
-]
-
-ApiKernelSessionOutputFile._fields = [
-  FieldMetadata("url", "url", "_url", str, None, PredefinedSerializer(), optional=True),
-  FieldMetadata("fileName", "file_name", "_file_name", str, None, PredefinedSerializer(), optional=True),
-]
-
-ApiListKernelFilesItem._fields = [
-  FieldMetadata("name", "name", "_name", str, "", PredefinedSerializer()),
-  FieldMetadata("size", "size", "_size", int, 0, PredefinedSerializer()),
-  FieldMetadata("creationDate", "creation_date", "_creation_date", str, "", PredefinedSerializer()),
+  FieldMetadata("kernelId", "kernel_id", "_kernel_id", int, 0, PredefinedSerializer()),
 ]