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

kagglesdk/kaggle_object.py

@@ -1,344 +0,0 @@
-import json
-import re
-from datetime import datetime, timedelta
-from google.protobuf.field_mask_pb2 import FieldMask
-
-
-class ObjectSerializer(object):
-
-    def __init__(self, to_dict_value, from_dict_value):
-        self.to_dict_value = to_dict_value
-        self.from_dict_value = from_dict_value
-
-
-class PredefinedSerializer(ObjectSerializer):
-
-    def __init__(self):
-        """Predefined objects such as int, float etc are serialized/deserialized directly."""
-        ObjectSerializer.__init__(self, lambda cls, v, _: v, lambda cls, v: v)
-
-
-# Adapted from https://stackoverflow.com/questions/1175208/elegant-python-function-to-convert-camelcase-to-snake-case
-_pascal_to_upper_snake_case_regex = re.compile("((?<=[a-z0-9])[A-Z]|(?!^)[A-Z](?=[a-z]))")
-
-
-def _pascal_case_to_upper_snake_case(string):
-    return _pascal_to_upper_snake_case_regex.sub(r"_\1", string).upper()
-
-
-def _convert(camel_input):
-    words = re.findall(r"[A-Z]?[a-z]+|[A-Z]{2,}(?=[A-Z][a-z]|\d|\W|$)|\d+", camel_input)
-    return "_".join(map(str.lower, words))
-
-
-class EnumSerializer(ObjectSerializer):
-
-    def __init__(self):
-        """
-        Enum objects are serialized using their ".name" field and deserialized by indexing the string in the Enum type.
-        Example:
-        class Foo(Enum):
-           TEST = 1
-        foo = Foo.TEST
-        foo.name # => returns "TEST"
-        Foo["TEST"] # => returns Foo.TEST enum value.
-        """
-        ObjectSerializer.__init__(
-            self,
-            lambda cls, v, _: EnumSerializer._to_str(cls, v),
-            lambda cls, v: EnumSerializer._from_str(cls, v),
-        )
-
-    @staticmethod
-    def _to_str(cls, v):
-        # "v" corresponds to an enum instance: Example foo or Foo.Test above.
-        # "cls" corresponds to the enum type Foo above.
-        return v.name
-
-    @staticmethod
-    def _from_str(cls, v):
-        # "v" corresponds to enum string: Example "TEST" above.
-        # "cls" corresponds to the enum type Foo above.
-        try:
-            return cls[v]
-        except KeyError:
-            dct = vars(cls)
-            n = v.lower()
-            nn = _convert(v).lower()
-            enum_prefix = _pascal_case_to_upper_snake_case(cls.__name__).lower()
-            for key in dct.keys():
-                k = key.lower()
-                if k == n:
-                    return dct[key]
-                if k.startswith(enum_prefix) and k.endswith(n) or k.endswith(nn):
-                    return dct[key]
-            raise
-
-
-class ListSerializer(ObjectSerializer):
-
-    def __init__(self, item_serializer: ObjectSerializer):
-        """
-        Lists are serialized based on the type they contain. Since objects are generated from proto files, a list always
-        contains objects of the same type, which is serialized/deserialized using "item_serializer".
-        """
-        ObjectSerializer.__init__(
-            self,
-            lambda cls, l, ignore_defaults: [item_serializer.to_dict_value(cls, v, ignore_defaults) for v in l],
-            lambda cls, l: [item_serializer.from_dict_value(cls, v) for v in l],
-        )
-
-
-class MapSerializer(ObjectSerializer):
-
-    def __init__(self, item_serializer: ObjectSerializer):
-        """
-        Maps are serialized based on type of their values. Since maps keys are always predefined types, we don't need a
-        serializer for them.
-        """
-        ObjectSerializer.__init__(
-            self,
-            lambda cls, d, ignore_defaults: {
-                k: item_serializer.to_dict_value(cls, v, ignore_defaults) for k, v in d.items()
-            },
-            lambda cls, d: {k: item_serializer.from_dict_value(cls, v) for k, v in d.items()},
-        )
-
-
-class DateTimeSerializer(ObjectSerializer):
-
-    def __init__(self):
-        """Date times are serialized/deserialized as a string in iso format"""
-        ObjectSerializer.__init__(
-            self,
-            lambda cls, dt, _: DateTimeSerializer._to_str(dt),
-            lambda _, v: DateTimeSerializer._from_str(v),
-        )
-
-    @staticmethod
-    def _to_str(dt):
-        return dt.isoformat(timespec="milliseconds") + "Z"
-
-    @staticmethod
-    def _from_str(v):
-        v = v.rstrip("Z")
-        fields = v.rsplit(".", maxsplit=1)
-        if len(fields) == 1:
-            return datetime.fromisoformat(v)
-        (dt, nanos) = fields
-        millis = nanos[:3]
-        try:
-            return datetime.fromisoformat(f"{dt}.{millis}")
-        except ValueError:
-            return datetime.fromisoformat(dt)  # Python 3.9, 3.10
-
-
-class TimeDeltaSerializer(ObjectSerializer):
-    # Scaling factors idea from https://github.com/protocolbuffers/protobuf/blob/master/csharp/src/Google.Protobuf/JsonParser.cs
-    SUBSECOND_SCALING_FACTORS = [
-        0,
-        100_000_000,
-        10_000_000,
-        1_000_000,
-        100_000,
-        10_000,
-        1_000,
-        100,
-        10,
-        1,
-    ]
-
-    def __init__(self):
-        """Time deltas are serialized/deserialized as a string in "<seconds>.<nanoseconds>s" format. Example: 151.500s"""
-        ObjectSerializer.__init__(
-            self,
-            lambda cls, t, _: TimeDeltaSerializer._to_dict_value(t),
-            lambda cls, v: TimeDeltaSerializer._from_dict_value(v),
-        )
-
-    @staticmethod
-    def _to_dict_value(delta):
-        seconds = delta.seconds
-        nanos_str = TimeDeltaSerializer._nanos_to_str(delta.microseconds * 1000)
-        if nanos_str is None:
-            return "{}s".format(seconds)
-        return "{}.{}s".format(seconds, nanos_str)
-
-    @staticmethod
-    def _nanos_to_str(nanos):
-        if nanos == 0:
-            return None
-        if nanos < 0:
-            nanos *= -1
-        if nanos % 1000000 == 0:
-            return "{}".format(nanos / 1000000)
-        elif nanos % 1000 == 0:
-            return "{}".format(nanos / 1000)
-        else:
-            return "{}".format(nanos)
-
-    @staticmethod
-    def _from_dict_value(value):
-        (seconds, nanosRaw) = value.rstrip("s").split(".")
-        nanos = int(nanosRaw) * TimeDeltaSerializer.SUBSECOND_SCALING_FACTORS[len(nanosRaw)]
-        return timedelta(seconds=int(seconds), microseconds=int(int(nanos) / 1000))
-
-
-class FieldMaskSerializer(ObjectSerializer):
-
-    def __init__(self):
-        """Field masks are serialized/deserialized as a string that contains a list of paths with a comma delimiter"""
-        ObjectSerializer.__init__(
-            self,
-            lambda cls, m, _: m.ToJsonString(),
-            lambda cls, v: FieldMaskSerializer._from_joined_paths(v),
-        )
-
-    @staticmethod
-    def _from_joined_paths(joined_paths):
-        mask = FieldMask()
-        mask.FromJsonString(joined_paths)
-        return mask
-
-
-class KaggleObjectSerializer(ObjectSerializer):
-
-    def __init__(self):
-        """
-        Kaggle objects (i.e., proto-generated types that inherit from KaggleObject) have custom "to_dict" and "from_dict"
-        methods that serialize/deserialize them to/from dictionaries.
-        """
-        ObjectSerializer.__init__(
-            self,
-            # "v" is an instance of a KaggleObject. For example: "req = ListCompetitionsRequest()".
-            # So "req.to_dict()" returns a dictionary with keys as json field names. Example:
-            # '{"pageSize": 10, "page": 2}'
-            lambda cls, v, ignore_defaults: cls.to_dict(v, ignore_defaults),
-            # "cls" is the type of a KaggleObject. For example: ListCompetitionsRequest. All
-            # generated Kaggle objects have "from_dict" class method that takes a dict to create a
-            # new instance of the object. See "KaggleObject" class definition below.
-            lambda cls, v: cls.from_dict(v),
-        )
-
-
-class FieldMetadata(object):
-
-    def __init__(
-        self,
-        json_name,
-        field_name,
-        private_field_name,
-        field_type,
-        default_value,
-        serializer,
-        optional=False,
-    ):
-        self.json_name = json_name
-        self.field_name = field_name
-        self.private_field_name = private_field_name
-        self.field_type = field_type
-        self.default_value = default_value
-        self.serializer = serializer
-        self.optional = optional
-
-    def get_as_dict_item(self, instance, ignore_defaults=True):
-        value = getattr(instance, self.private_field_name)
-        if ignore_defaults and value == self.default_value:
-            return None
-        if value is None:
-            return None
-        return self.serializer.to_dict_value(self.field_type, value, ignore_defaults)
-
-    def set_from_dict(self, instance, json_dict):
-        if self.json_name not in json_dict:
-            return  # Ignore unknown fields
-        value = json_dict[self.json_name]
-        if value == self.default_value:
-            return  # Ignore default values
-        try:
-            setattr(
-                instance,
-                self.private_field_name,
-                self.serializer.from_dict_value(self.field_type, value),
-            )
-        except Exception as e:
-            raise
-
-
-class KaggleObject(object):
-
-    def endpoint(self):
-        raise "Error: endpoint must be defined by the request object"
-
-    @staticmethod
-    def endpoint_path():
-        return None
-
-    @staticmethod
-    def body_fields():
-        return None
-
-    @classmethod
-    def prepare_from(cls, http_response):
-        return cls.from_json(http_response.text)
-
-    @staticmethod
-    def method():
-        return "GET"
-
-    def _freeze(self):
-        self._is_frozen = True
-
-    def __setattr__(self, key, value):
-        if hasattr(self, "_is_frozen") and not hasattr(self, key):
-            raise AttributeError(f"Unknown field for {self.__class__.__name__}: {key}")
-        object.__setattr__(self, key, value)
-
-    def to_dict(self, ignore_defaults=True):
-        kv_pairs = [(field.json_name, field.get_as_dict_item(self, ignore_defaults)) for field in self._fields]
-        return {k: v for (k, v) in kv_pairs if not ignore_defaults or v is not None}
-
-    def to_field_map(self, ignore_defaults=True):
-        kv_pairs = [(field.field_name, field.get_as_dict_item(self, ignore_defaults)) for field in self._fields]
-        return {k: v for (k, v) in kv_pairs if not ignore_defaults or v is not None}
-
-    @classmethod
-    def from_dict(cls, json_dict):
-        instance = cls()
-        for field in cls._fields:
-            field.set_from_dict(instance, json_dict)
-        return instance
-
-    @classmethod
-    def from_json(cls, json_str):
-        return cls.from_dict(json.loads(json_str))
-
-    def to_json(self, ignore_defaults=True):
-        return json.dumps(self.to_dict(ignore_defaults))
-
-    def __str__(self):
-        return self.to_json(ignore_defaults=False)
-
-    def __repr__(self):
-        return self.to_json(ignore_defaults=False)
-
-    def __contains__(self, field_name):
-        try:
-            field = self._get_field(field_name)
-        except ValueError:
-            return False
-        value = getattr(self, field.private_field_name)
-        if field.optional:
-            return value is not None
-        else:
-            return value != field.default_value
-
-    def __delattr__(self, field_name):
-        field = self._get_field(field_name)
-        setattr(self, field.private_field_name, field.default_value)
-
-    def _get_field(self, field_name):
-        field = next((f for f in self._fields if f.field_name == field_name), None)
-        if field is None:
-            raise ValueError(f'Protocol message {self.__class__.__name__} has no "{field_name}" field.')
-        return field

kagglesdk/kernels/services/kernels_api_service.py

@@ -1,146 +0,0 @@
-from kagglesdk.common.types.file_download import FileDownload
-from kagglesdk.common.types.http_redirect import HttpRedirect
-from kagglesdk.common.types.operations import Operation
-from kagglesdk.kaggle_http_client import KaggleHttpClient
-from kagglesdk.kernels.types.kernels_api_service import ApiCancelKernelSessionRequest, ApiCancelKernelSessionResponse, ApiCreateKernelSessionRequest, ApiDeleteKernelRequest, ApiDeleteKernelResponse, ApiDownloadKernelOutputRequest, ApiDownloadKernelOutputZipRequest, ApiGetKernelRequest, ApiGetKernelResponse, ApiGetKernelSessionStatusRequest, ApiGetKernelSessionStatusResponse, ApiListKernelFilesRequest, ApiListKernelFilesResponse, ApiListKernelSessionOutputRequest, ApiListKernelSessionOutputResponse, ApiListKernelsRequest, ApiListKernelsResponse, ApiSaveKernelRequest, ApiSaveKernelResponse
-
-class KernelsApiClient(object):
-
-  def __init__(self, client: KaggleHttpClient):
-    self._client = client
-
-  def list_kernels(self, request: ApiListKernelsRequest = None) -> ApiListKernelsResponse:
-    r"""
-    Args:
-      request (ApiListKernelsRequest):
-        The request object; initialized to empty instance if not specified.
-    """
-
-    if request is None:
-      request = ApiListKernelsRequest()
-
-    return self._client.call("kernels.KernelsApiService", "ListKernels", request, ApiListKernelsResponse)
-
-  def list_kernel_files(self, request: ApiListKernelFilesRequest = None) -> ApiListKernelFilesResponse:
-    r"""
-    Args:
-      request (ApiListKernelFilesRequest):
-        The request object; initialized to empty instance if not specified.
-    """
-
-    if request is None:
-      request = ApiListKernelFilesRequest()
-
-    return self._client.call("kernels.KernelsApiService", "ListKernelFiles", request, ApiListKernelFilesResponse)
-
-  def get_kernel(self, request: ApiGetKernelRequest = None) -> ApiGetKernelResponse:
-    r"""
-    Args:
-      request (ApiGetKernelRequest):
-        The request object; initialized to empty instance if not specified.
-    """
-
-    if request is None:
-      request = ApiGetKernelRequest()
-
-    return self._client.call("kernels.KernelsApiService", "GetKernel", request, ApiGetKernelResponse)
-
-  def save_kernel(self, request: ApiSaveKernelRequest = None) -> ApiSaveKernelResponse:
-    r"""
-    Args:
-      request (ApiSaveKernelRequest):
-        The request object; initialized to empty instance if not specified.
-    """
-
-    if request is None:
-      request = ApiSaveKernelRequest()
-
-    return self._client.call("kernels.KernelsApiService", "SaveKernel", request, ApiSaveKernelResponse)
-
-  def list_kernel_session_output(self, request: ApiListKernelSessionOutputRequest = None) -> ApiListKernelSessionOutputResponse:
-    r"""
-    Args:
-      request (ApiListKernelSessionOutputRequest):
-        The request object; initialized to empty instance if not specified.
-    """
-
-    if request is None:
-      request = ApiListKernelSessionOutputRequest()
-
-    return self._client.call("kernels.KernelsApiService", "ListKernelSessionOutput", request, ApiListKernelSessionOutputResponse)
-
-  def get_kernel_session_status(self, request: ApiGetKernelSessionStatusRequest = None) -> ApiGetKernelSessionStatusResponse:
-    r"""
-    Args:
-      request (ApiGetKernelSessionStatusRequest):
-        The request object; initialized to empty instance if not specified.
-    """
-
-    if request is None:
-      request = ApiGetKernelSessionStatusRequest()
-
-    return self._client.call("kernels.KernelsApiService", "GetKernelSessionStatus", request, ApiGetKernelSessionStatusResponse)
-
-  def download_kernel_output(self, request: ApiDownloadKernelOutputRequest = None) -> HttpRedirect:
-    r"""
-    Meant for use by Kaggle Hub (http bindings and terminology align with that)
-
-    Args:
-      request (ApiDownloadKernelOutputRequest):
-        The request object; initialized to empty instance if not specified.
-    """
-
-    if request is None:
-      request = ApiDownloadKernelOutputRequest()
-
-    return self._client.call("kernels.KernelsApiService", "DownloadKernelOutput", request, HttpRedirect)
-
-  def download_kernel_output_zip(self, request: ApiDownloadKernelOutputZipRequest = None) -> FileDownload:
-    r"""
-    Meant for use by Kaggle Hub (and DownloadKernelOutput above)
-
-    Args:
-      request (ApiDownloadKernelOutputZipRequest):
-        The request object; initialized to empty instance if not specified.
-    """
-
-    if request is None:
-      request = ApiDownloadKernelOutputZipRequest()
-
-    return self._client.call("kernels.KernelsApiService", "DownloadKernelOutputZip", request, FileDownload)
-
-  def delete_kernel(self, request: ApiDeleteKernelRequest = None) -> ApiDeleteKernelResponse:
-    r"""
-    Args:
-      request (ApiDeleteKernelRequest):
-        The request object; initialized to empty instance if not specified.
-    """
-
-    if request is None:
-      request = ApiDeleteKernelRequest()
-
-    return self._client.call("kernels.KernelsApiService", "DeleteKernel", request, ApiDeleteKernelResponse)
-
-  def cancel_kernel_session(self, request: ApiCancelKernelSessionRequest = None) -> ApiCancelKernelSessionResponse:
-    r"""
-    Args:
-      request (ApiCancelKernelSessionRequest):
-        The request object; initialized to empty instance if not specified.
-    """
-
-    if request is None:
-      request = ApiCancelKernelSessionRequest()
-
-    return self._client.call("kernels.KernelsApiService", "CancelKernelSession", request, ApiCancelKernelSessionResponse)
-
-  def create_kernel_session(self, request: ApiCreateKernelSessionRequest = None) -> Operation:
-    r"""
-    Args:
-      request (ApiCreateKernelSessionRequest):
-        The request object; initialized to empty instance if not specified.
-    """
-
-    if request is None:
-      request = ApiCreateKernelSessionRequest()
-
-    return self._client.call("kernels.KernelsApiService", "CreateKernelSession", request, Operation)