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

kaggle/models/upload_file.py

@@ -21,7 +21,7 @@ import re  # noqa: F401
 
 import six
 
-from kaggle.models.dataset_column import DatasetColumn  # noqa: F401,E501
+from kagglesdk.datasets.types.dataset_api_service import ApiDatasetColumn
 
 
 class UploadFile(object):
@@ -33,7 +33,7 @@ class UploadFile(object):
                             and the value is json key in definition.
     """
 
-    column_types = {"token": "str", "description": "str", "columns": "list[DatasetColumn]"}
+    column_types = {"token": "str", "description": "str", "columns": "list[ApiDatasetColumn]"}
 
     attribute_map = {"token": "token", "description": "description", "columns": "columns"}
 
@@ -107,7 +107,7 @@ class UploadFile(object):
         A list of dataset column metadata  # noqa: E501
 
         :return: The columns of this UploadFile.  # noqa: E501
-        :rtype: list[DatasetColumn]
+        :rtype: list[ApiDatasetColumn]
         """
         return self._columns
 
@@ -118,7 +118,7 @@ class UploadFile(object):
         A list of dataset column metadata  # noqa: E501
 
         :param columns: The columns of this UploadFile.  # noqa: E501
-        :type: list[DatasetColumn]
+        :type: list[ApiDatasetColumn]
         """
 
         self._columns = columns

{kaggle-1.8.3.dist-info → kaggle-1.8.4.dist-info}/METADATA

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: kaggle
-Version: 1.8.3
+Version: 1.8.4
 Summary: Access Kaggle resources anywhere
-Project-URL: Homepage, https://github.com/Kaggle/kaggle-api
-Project-URL: Issues, https://github.com/Kaggle/kaggle-api/issues
+Project-URL: Homepage, https://github.com/Kaggle/kaggle-cli
+Project-URL: Issues, https://github.com/Kaggle/kaggle-cli/issues
 Author-email: Kaggle <support@kaggle.com>
 License:                                  Apache License
                                    Version 2.0, January 2004
@@ -212,46 +212,57 @@ Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.11
-Requires-Dist: black>=24.10.0
 Requires-Dist: bleach
-Requires-Dist: kagglesdk<1.0,>=0.1.14
-Requires-Dist: mypy>=1.15.0
+Requires-Dist: kagglesdk<1.0,>=0.1.15
 Requires-Dist: packaging
 Requires-Dist: protobuf
 Requires-Dist: python-dateutil
 Requires-Dist: python-slugify
 Requires-Dist: requests
-Requires-Dist: six>=1.10
 Requires-Dist: tqdm
-Requires-Dist: types-requests
-Requires-Dist: types-tqdm
 Requires-Dist: urllib3>=1.15.1
 Description-Content-Type: text/markdown
 
-# Kaggle API
+# Kaggle CLI
 
-Official API for https://www.kaggle.com, accessible using a command line tool implemented in Python 3.  
+The official CLI to interact with [Kaggle](https://www.kaggle.com).
+
+---
 
 [User documentation](docs/README.md)
 
-## Installation
+---
 
-Ensure you have Python 3 and the package manager `pip` installed.
+## Key Features
 
-Run the following command to access the Kaggle API using the command line:
+Some of the key features are:
+
+* List competitions, download competition data, submit to a competition.
+* List, create, update, download or delete datasets.
+* List, create, update, download or delete models & model variations.
+* List, update & run, download code & output or delete kernels (notebooks).
+
+## Installation
+
+Install the `kaggle` package with [pip](https://pypi.org/project/pip/):
 
 ```sh
 pip install kaggle
 ```
 
-## Development
+Additional installation instructions can be found [here](docs/README.md#installation).
 
-### Kaggle Internal
+## Quick start
 
-Obviously, this depends on Kaggle services. When you're extending the API and modifying
-or adding to those services, you should be working in your Kaggle mid-tier development
-environment. You'll run Kaggle locally, in the container, and test the Python code by
-running it in the container so it can connect to your local testing environment.
+Explore the available commands by running:
+
+```sh
+kaggle --help
+```
+
+See the [User documentation](docs/README.md) for more examples & tutorials.
+
+## Development
 
 ### Prerequisites
 
@@ -259,87 +270,67 @@ We use [hatch](https://hatch.pypa.io) to manage this project.
 
 Follow these [instructions](https://hatch.pypa.io/latest/install/) to install it.
 
-If you are working in a managed environment, you may want to use `pipx`. If it isn't already installed
-try `sudo apt install pipx`. Then you should be able to proceed with `pipx install hatch`.
+### Run `kaggle` from source
 
-### Dependencies
+#### Option 1: Execute a one-liner of code from the command line
 
 ```sh
-hatch run install-deps
+hatch run kaggle datasets list
 ```
 
-### Compile
+#### Option 2: Run many commands in a shell
 
 ```sh
-hatch run compile
+hatch shell
+
+# Inside the shell, you can run many commands
+kaggle datasets list
+kaggle competitions list
+...
 ```
 
-The compiled files are generated in the `kaggle/` directory from the `src/` directory.
+### Lint / Format
 
-All the changes must be done in the `src/` directory.
+```sh
+# Lint check
+hatch run lint:style
+hatch run lint:typing
+hatch run lint:all     # for both
 
-### Run
+# Format
+hatch run lint:fmt
+```
 
-Use `hatch run install` to compile the program and install it in the default `hatch` environment.
-To run that version locally for testing, use hatch: `hatch run kaggle -v`. If you'd rather not
-type `hatch run` every time, launch a new shell in the hatch environment: `hatch shell`.
+### Tests
 
-You can also run the code in python directly:
+Note: These tests are not true unit tests and are calling the Kaggle web server.
 
 ```sh
-hatch run python
-```
-
-```python
-import kaggle
-from kaggle.api.kaggle_api_extended import KaggleApi
-api = KaggleApi()
-api.authenticate()
-api.model_list_cli()
-
-Next Page Token = [...]
-[...]
+# Run against kaggle.com
+hatch run test:prod
 
+# Run against a local web server (Kaggle engineers only)
+hatch run test:local
 ```
 
-Or in a single command:
-
-```sh
-hatch run python -c "import kaggle; from kaggle.api.kaggle_api_extended import KaggleApi; api = KaggleApi(); api.authenticate(); api.model_list_cli()"
-```
+### Integration Tests
 
-### Example
+To run integration tests on your local machine, you need to set up your Kaggle credentials. You can do this by following the [authentication instructions](docs/README.md#authentication).
 
-Let's change the `model_list_cli` method in the source file: 
+After setting up your credentials, you can run the integration tests as follows:
 
 ```sh
-❯ git diff src/kaggle/api/kaggle_api_extended.py
-[...]
-+        print('hello Kaggle CLI update')^M
-         models = self.model_list(sort_by, search, owner, page_size, page_token)
-[...]
-
-❯ hatch run compile
-[...]
-
-❯ hatch run python -c "import kaggle; from kaggle.api.kaggle_api_extended import KaggleApi; api = KaggleApi(); api.authenticate(); api.model_list_cli()"
-hello Kaggle CLI update
-Next Page Token = [...]
+hatch run test:integration
 ```
 
-### Integration Tests
+## Changelog
 
-To run integration tests on your local machine, you need to set up your Kaggle API credentials. You can do this in one of these two ways described [this doc](docs/README.md). Refer to the sections: 
-- Using environment variables
-- Using credentials file
+See [CHANGELOG](CHANGELOG.md).
 
-After setting up your credentials by any of these methods, you can run the integration tests as follows:
+## Contributing
 
-```sh
-# Run all tests
-hatch run integration-test
-```
+See [CONTRIBUTING.md](CONTRIBUTING.md).
 
 ## License
 
-The Kaggle API is released under the [Apache 2.0 license](LICENSE).
+The Kaggle CLI is released under the [Apache 2.0 license](LICENSE.txt).

kaggle-1.8.4.dist-info/RECORD

@@ -0,0 +1,15 @@
+kaggle/LICENSE,sha256=PN5H3cwV3xW9nvUXKcB_XOH60cWqne6qK3SAE8NI74s,11340
+kaggle/__init__.py,sha256=fUks8_ewdXRldJ0jq82KRKgsyUae8DtxU6QFrGtaxeE,280
+kaggle/cli.py,sha256=f6RX_XZJNwMkbj5ftDSHcHGrV_czqwWrfRqK63y-Lx0,69820
+kaggle/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+kaggle/api/kaggle_api.py,sha256=k_Fm5TxiUM6O19dMy43XTdYyBNIWWGWDE9QRf6otwUE,25521
+kaggle/api/kaggle_api_extended.py,sha256=H50hT_jbQcD0DirfX89jT3HvqGiX6Eko3LyAx_gulFI,228320
+kaggle/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+kaggle/models/kaggle_models_extended.py,sha256=w-IEn0AQvIZRj3ialSoOMOJm8vu48whqte36IdggI7Q,7997
+kaggle/models/upload_file.py,sha256=i_8CfypwOToCoxAvG96Gle3IgNkrVnc38Y4oMHKqNjg,5081
+kaggle/test/test_authenticate.py,sha256=6HvLhQ4noCXs3hVJpQP-tlSYv1_I9kKfAT2Nu3PeC7Q,1185
+kaggle-1.8.4.dist-info/METADATA,sha256=KD5dM79V1y57b-X76cdRuWi0pvmn45oMYOkR1y0fpTA,15925
+kaggle-1.8.4.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+kaggle-1.8.4.dist-info/entry_points.txt,sha256=hl3dQAS4qpVkC5FWiqfnU6qKJU924OEN6PsHEiw-FGg,43
+kaggle-1.8.4.dist-info/licenses/LICENSE.txt,sha256=IzhfWrxIlFAci3lzZCg5WWHZJBI1QSzsHxO0plI63vk,11541
+kaggle-1.8.4.dist-info/RECORD,,

kaggle/models/api_blob_type.py

@@ -1,4 +0,0 @@
-class ApiBlobType(object):
-    DATASET = "dataset"
-    MODEL = "model"
-    INBOX = "inbox"

kaggle/models/dataset_column.py

@@ -1,228 +0,0 @@
-#!/usr/bin/python
-#
-# Copyright 2024 Kaggle Inc
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-# coding: utf-8
-
-import pprint
-import re  # noqa: F401
-
-import six
-
-
-class DatasetColumn(object):
-    """
-    Attributes:
-      column_types (dict): The key is attribute name
-                            and the value is attribute type.
-      attribute_map (dict): The key is attribute name
-                            and the value is json key in definition.
-    """
-
-    column_types = {"order": "float", "name": "str", "type": "str", "original_type": "str", "description": "str"}
-
-    attribute_map = {
-        "order": "order",
-        "name": "name",
-        "type": "type",
-        "original_type": "originalType",
-        "description": "description",
-    }
-
-    def __init__(self, order=None, name=None, type=None, original_type=None, description=None):  # noqa: E501
-        """DatasetColumn - a model defined in Swagger"""  # noqa: E501
-
-        self._order = None
-        self._name = None
-        self._type = None
-        self._original_type = None
-        self._description = None
-        self.discriminator = None
-
-        if order is not None:
-            self.order = order
-        if name is not None:
-            self.name = name
-        if type is not None:
-            self.type = type
-        if original_type is not None:
-            self.original_type = original_type
-        if description is not None:
-            self.description = description
-
-    @property
-    def order(self):
-        """Gets the order of this DatasetColumn.  # noqa: E501.
-
-        The order that the column comes in, 0-based. (The first column is 0,
-        second is 1, etc.)  # noqa: E501
-
-        :return: The order of this DatasetColumn.  # noqa: E501
-        :rtype: float
-        """
-        return self._order
-
-    @order.setter
-    def order(self, order):
-        """Sets the order of this DatasetColumn.
-
-        The order that the column comes in, 0-based. (The first column is 0,
-        second is 1, etc.)  # noqa: E501
-
-        :param order: The order of this DatasetColumn.  # noqa: E501
-        :type: float
-        """
-
-        self._order = order
-
-    @property
-    def name(self):
-        """Gets the name of this DatasetColumn.  # noqa: E501.
-
-        The column name  # noqa: E501
-
-        :return: The name of this DatasetColumn.  # noqa: E501
-        :rtype: str
-        """
-        return self._name
-
-    @name.setter
-    def name(self, name):
-        """Sets the name of this DatasetColumn.
-
-        The column name  # noqa: E501
-
-        :param name: The name of this DatasetColumn.  # noqa: E501
-        :type: str
-        """
-
-        self._name = name
-
-    @property
-    def type(self):
-        """Gets the type of this DatasetColumn.  # noqa: E501.
-
-        The type of all of the fields in the column. Please see the data
-        types on
-        https://github.com/Kaggle/kaggle-api/wiki/Dataset-Metadata
-         # noqa: E501
-
-        :return: The type of this DatasetColumn.  # noqa: E501
-        :rtype: str
-        """
-        return self._type
-
-    @type.setter
-    def type(self, type):
-        """Sets the type of this DatasetColumn.
-
-        The type of all of the fields in the column. Please see the data
-        types on
-        https://github.com/Kaggle/kaggle-api/wiki/Dataset-Metadata
-         # noqa: E501
-
-        :param type: The type of this DatasetColumn.  # noqa: E501
-        :type: str
-        """
-
-        self._type = type
-
-    @property
-    def original_type(self):
-        """Gets the original_type of this DatasetColumn.  # noqa: E501.
-
-        Used to store the original type of the column, which will be converted to Kaggle's types. For example, an `originalType` of `\"integer\"` would convert to a `type` of `\"numeric\"`  # noqa: E501
-
-        :return: The original_type of this DatasetColumn.  # noqa: E501
-        :rtype: str
-        """
-        return self._original_type
-
-    @original_type.setter
-    def original_type(self, original_type):
-        """Sets the original_type of this DatasetColumn.
-
-        Used to store the original type of the column, which will be converted to Kaggle's types. For example, an `originalType` of `\"integer\"` would convert to a `type` of `\"numeric\"`  # noqa: E501
-
-        :param original_type: The original_type of this DatasetColumn.  # noqa: E501
-        :type: str
-        """
-
-        self._original_type = original_type
-
-    @property
-    def description(self):
-        """Gets the description of this DatasetColumn.  # noqa: E501.
-
-        The description of the column  # noqa: E501
-
-        :return: The description of this DatasetColumn.  # noqa: E501
-        :rtype: str
-        """
-        return self._description
-
-    @description.setter
-    def description(self, description):
-        """Sets the description of this DatasetColumn.
-
-        The description of the column  # noqa: E501
-
-        :param description: The description of this DatasetColumn. # noqa:
-            E501
-        :type: str
-        """
-
-        self._description = description
-
-    def to_dict(self):
-        """Returns the model properties as a dict."""
-        result = {}
-
-        for attr, _ in six.iteritems(self.column_types):
-            value = getattr(self, attr)
-            if isinstance(value, list):
-                result[attr] = list(map(lambda x: x.to_dict() if hasattr(x, "to_dict") else x, value))
-            elif hasattr(value, "to_dict"):
-                result[attr] = value.to_dict()
-            elif isinstance(value, dict):
-                result[attr] = dict(
-                    map(
-                        lambda item: (item[0], item[1].to_dict()) if hasattr(item[1], "to_dict") else item,
-                        value.items(),
-                    )
-                )
-            else:
-                result[attr] = value
-
-        return result
-
-    def to_str(self):
-        """Returns the string representation of the model."""
-        return pprint.pformat(self.to_dict())
-
-    def __repr__(self):
-        """For `print` and `pprint`"""
-        return self.to_str()
-
-    def __eq__(self, other):
-        """Returns true if both objects are equal."""
-        if not isinstance(other, DatasetColumn):
-            return False
-
-        return self.__dict__ == other.__dict__
-
-    def __ne__(self, other):
-        """Returns true if both objects are not equal."""
-        return not self == other