WIP: Update kagglesdk to test new Kaggle CLI functionality.

kagglesdk/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.1.16"
+__version__ = "0.1.15"
 
 from kagglesdk.kaggle_client import KaggleClient
 from kagglesdk.kaggle_creds import KaggleCredentials

kagglesdk/abuse/services/abuse_service.py

@@ -0,0 +1,51 @@
+from kagglesdk.abuse.types.abuse_service import AdminAllowlistEntityRequest, RemoveDatasetVersionQuarantineRequest, SetReportedDismissalRequest
+from kagglesdk.kaggle_http_client import KaggleHttpClient
+
+class AbuseClient(object):
+
+  def __init__(self, client: KaggleHttpClient):
+    self._client = client
+
+  def set_reported_dismissal(self, request: SetReportedDismissalRequest = None):
+    r"""
+    Set dismissal state for a given entity (only applicable to notebooks /
+    datasets)
+
+    Args:
+      request (SetReportedDismissalRequest):
+        The request object; initialized to empty instance if not specified.
+    """
+
+    if request is None:
+      request = SetReportedDismissalRequest()
+
+    self._client.call("abuse.AbuseService", "SetReportedDismissal", request, None)
+
+  def admin_allowlist_entity(self, request: AdminAllowlistEntityRequest = None):
+    r"""
+    An admin only method to allowlist an entity, marking it as no longer
+    moderated automatically
+
+    Args:
+      request (AdminAllowlistEntityRequest):
+        The request object; initialized to empty instance if not specified.
+    """
+
+    if request is None:
+      request = AdminAllowlistEntityRequest()
+
+    self._client.call("abuse.AbuseService", "AdminAllowlistEntity", request, None)
+
+  def remove_dataset_version_quarantine(self, request: RemoveDatasetVersionQuarantineRequest = None):
+    r"""
+    Removes a quarantine on a dataset version, if applicable.
+
+    Args:
+      request (RemoveDatasetVersionQuarantineRequest):
+        The request object; initialized to empty instance if not specified.
+    """
+
+    if request is None:
+      request = RemoveDatasetVersionQuarantineRequest()
+
+    self._client.call("abuse.AbuseService", "RemoveDatasetVersionQuarantine", request, None)

kagglesdk/abuse/types/abuse_enums.py

@@ -0,0 +1,7 @@
+import enum
+
+class PrivatedModerationStatus(enum.Enum):
+  PRIVATED_MODERATION_STATUS_UNSPECIFIED = 0
+  PRIVATED_MODERATION_STATUS_NO_ABUSE = 1
+  PERMANENTLY_PRIVATED = 3
+

kagglesdk/abuse/types/abuse_service.py

@@ -0,0 +1,190 @@
+import enum
+from kagglesdk.common.types.common_types import KaggleEntityType
+from kagglesdk.kaggle_object import *
+from typing import Optional
+
+class ReportedDismissalType(enum.Enum):
+  REPORTED_DISMISSAL_TYPE_UNSPECIFIED = 0
+  BANNER = 1
+  MODAL = 2
+
+class AdminAllowlistEntityRequest(KaggleObject):
+  r"""
+  Attributes:
+    entity_id (int)
+      The entity ID to allowlist
+    entity_type (KaggleEntityType)
+      The entity type of the allowlisted entity
+  """
+
+  def __init__(self):
+    self._entity_id = 0
+    self._entity_type = KaggleEntityType.KAGGLE_ENTITY_TYPE_UNSPECIFIED
+    self._freeze()
+
+  @property
+  def entity_id(self) -> int:
+    """The entity ID to allowlist"""
+    return self._entity_id
+
+  @entity_id.setter
+  def entity_id(self, entity_id: int):
+    if entity_id is None:
+      del self.entity_id
+      return
+    if not isinstance(entity_id, int):
+      raise TypeError('entity_id must be of type int')
+    self._entity_id = entity_id
+
+  @property
+  def entity_type(self) -> 'KaggleEntityType':
+    """The entity type of the allowlisted entity"""
+    return self._entity_type
+
+  @entity_type.setter
+  def entity_type(self, entity_type: 'KaggleEntityType'):
+    if entity_type is None:
+      del self.entity_type
+      return
+    if not isinstance(entity_type, KaggleEntityType):
+      raise TypeError('entity_type must be of type KaggleEntityType')
+    self._entity_type = entity_type
+
+
+class RemoveDatasetVersionQuarantineRequest(KaggleObject):
+  r"""
+  Attributes:
+    dataset_version_id (int)
+      The dataset version to unquarantine
+    reason (str)
+      Admin reasoning for the quarantine removal
+  """
+
+  def __init__(self):
+    self._dataset_version_id = 0
+    self._reason = None
+    self._freeze()
+
+  @property
+  def dataset_version_id(self) -> int:
+    """The dataset version to unquarantine"""
+    return self._dataset_version_id
+
+  @dataset_version_id.setter
+  def dataset_version_id(self, dataset_version_id: int):
+    if dataset_version_id is None:
+      del self.dataset_version_id
+      return
+    if not isinstance(dataset_version_id, int):
+      raise TypeError('dataset_version_id must be of type int')
+    self._dataset_version_id = dataset_version_id
+
+  @property
+  def reason(self) -> str:
+    """Admin reasoning for the quarantine removal"""
+    return self._reason or ""
+
+  @reason.setter
+  def reason(self, reason: Optional[str]):
+    if reason is None:
+      del self.reason
+      return
+    if not isinstance(reason, str):
+      raise TypeError('reason must be of type str')
+    self._reason = reason
+
+
+class SetReportedDismissalRequest(KaggleObject):
+  r"""
+  Attributes:
+    entity_id (int)
+      The ID for the entity to dismiss
+    entity_type (KaggleEntityType)
+      The type for the entity to dismiss
+    is_dismissed (bool)
+      The value to set dismissal to
+    dismissal_type (ReportedDismissalType)
+      Whether we're dismissing a banner or a modal
+  """
+
+  def __init__(self):
+    self._entity_id = 0
+    self._entity_type = KaggleEntityType.KAGGLE_ENTITY_TYPE_UNSPECIFIED
+    self._is_dismissed = False
+    self._dismissal_type = ReportedDismissalType.REPORTED_DISMISSAL_TYPE_UNSPECIFIED
+    self._freeze()
+
+  @property
+  def entity_id(self) -> int:
+    """The ID for the entity to dismiss"""
+    return self._entity_id
+
+  @entity_id.setter
+  def entity_id(self, entity_id: int):
+    if entity_id is None:
+      del self.entity_id
+      return
+    if not isinstance(entity_id, int):
+      raise TypeError('entity_id must be of type int')
+    self._entity_id = entity_id
+
+  @property
+  def entity_type(self) -> 'KaggleEntityType':
+    """The type for the entity to dismiss"""
+    return self._entity_type
+
+  @entity_type.setter
+  def entity_type(self, entity_type: 'KaggleEntityType'):
+    if entity_type is None:
+      del self.entity_type
+      return
+    if not isinstance(entity_type, KaggleEntityType):
+      raise TypeError('entity_type must be of type KaggleEntityType')
+    self._entity_type = entity_type
+
+  @property
+  def is_dismissed(self) -> bool:
+    """The value to set dismissal to"""
+    return self._is_dismissed
+
+  @is_dismissed.setter
+  def is_dismissed(self, is_dismissed: bool):
+    if is_dismissed is None:
+      del self.is_dismissed
+      return
+    if not isinstance(is_dismissed, bool):
+      raise TypeError('is_dismissed must be of type bool')
+    self._is_dismissed = is_dismissed
+
+  @property
+  def dismissal_type(self) -> 'ReportedDismissalType':
+    """Whether we're dismissing a banner or a modal"""
+    return self._dismissal_type
+
+  @dismissal_type.setter
+  def dismissal_type(self, dismissal_type: 'ReportedDismissalType'):
+    if dismissal_type is None:
+      del self.dismissal_type
+      return
+    if not isinstance(dismissal_type, ReportedDismissalType):
+      raise TypeError('dismissal_type must be of type ReportedDismissalType')
+    self._dismissal_type = dismissal_type
+
+
+AdminAllowlistEntityRequest._fields = [
+  FieldMetadata("entityId", "entity_id", "_entity_id", int, 0, PredefinedSerializer()),
+  FieldMetadata("entityType", "entity_type", "_entity_type", KaggleEntityType, KaggleEntityType.KAGGLE_ENTITY_TYPE_UNSPECIFIED, EnumSerializer()),
+]
+
+RemoveDatasetVersionQuarantineRequest._fields = [
+  FieldMetadata("datasetVersionId", "dataset_version_id", "_dataset_version_id", int, 0, PredefinedSerializer()),
+  FieldMetadata("reason", "reason", "_reason", str, None, PredefinedSerializer(), optional=True),
+]
+
+SetReportedDismissalRequest._fields = [
+  FieldMetadata("entityId", "entity_id", "_entity_id", int, 0, PredefinedSerializer()),
+  FieldMetadata("entityType", "entity_type", "_entity_type", KaggleEntityType, KaggleEntityType.KAGGLE_ENTITY_TYPE_UNSPECIFIED, EnumSerializer()),
+  FieldMetadata("isDismissed", "is_dismissed", "_is_dismissed", bool, False, PredefinedSerializer()),
+  FieldMetadata("dismissalType", "dismissal_type", "_dismissal_type", ReportedDismissalType, ReportedDismissalType.REPORTED_DISMISSAL_TYPE_UNSPECIFIED, EnumSerializer()),
+]
+

kagglesdk/active_events/services/active_event_service.py

@@ -0,0 +1,51 @@
+from kagglesdk.active_events.types.active_event import ActiveEvent
+from kagglesdk.active_events.types.active_event_service import DeleteActiveEventRequest, DummyActiveEventRequest, GetActiveEventsFirebaseConfigRequest, GetActiveEventsFirebaseConfigResponse
+from kagglesdk.kaggle_http_client import KaggleHttpClient
+
+class ActiveEventClient(object):
+  """See go/kaggle-active-events-guide for how to add a new active event."""
+
+  def __init__(self, client: KaggleHttpClient):
+    self._client = client
+
+  def delete_active_event(self, request: DeleteActiveEventRequest = None):
+    r"""
+    DeleteActiveEvent deletes the specified ActiveEvent from firestore under
+    the current user.
+
+    Args:
+      request (DeleteActiveEventRequest):
+        The request object; initialized to empty instance if not specified.
+    """
+
+    if request is None:
+      request = DeleteActiveEventRequest()
+
+    self._client.call("active_events.ActiveEventService", "DeleteActiveEvent", request, None)
+
+  def get_active_events_firebase_config(self, request: GetActiveEventsFirebaseConfigRequest = None) -> GetActiveEventsFirebaseConfigResponse:
+    r"""
+    Args:
+      request (GetActiveEventsFirebaseConfigRequest):
+        The request object; initialized to empty instance if not specified.
+    """
+
+    if request is None:
+      request = GetActiveEventsFirebaseConfigRequest()
+
+    return self._client.call("active_events.ActiveEventService", "GetActiveEventsFirebaseConfig", request, GetActiveEventsFirebaseConfigResponse)
+
+  def dummy_active_event(self, request: DummyActiveEventRequest = None) -> ActiveEvent:
+    r"""
+    Dummy rpc to generate Wire3 format fromJson/toJson typescript methods.
+    These methods are used to deserialize enum from Firestore in the frontend.
+
+    Args:
+      request (DummyActiveEventRequest):
+        The request object; initialized to empty instance if not specified.
+    """
+
+    if request is None:
+      request = DummyActiveEventRequest()
+
+    return self._client.call("active_events.ActiveEventService", "DummyActiveEvent", request, ActiveEvent)