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

kaggle/cli.py

@@ -35,8 +35,8 @@ def main() -> None:
         "-v",
         "--version",
         action="version",
-        help="Print the Kaggle API version",
-        version="Kaggle API " + kaggle.__version__,
+        help="Print the Kaggle CLI version",
+        version="Kaggle CLI " + kaggle.__version__,
     )
     parser.add_argument(
         "-W",
@@ -550,6 +550,7 @@ def parse_kernels(subparsers) -> None:
     parser_kernels_push_optional.add_argument(
         "-t", "--timeout", type=int, dest="timeout", help=Help.param_kernel_timeout
     )
+    parser_kernels_push_optional.add_argument("--accelerator", dest="acc", help=Help.param_kernel_acc)
     parser_kernels_push._action_groups.append(parser_kernels_push_optional)
     parser_kernels_push.set_defaults(func=api.kernels_push_cli)
 
@@ -592,6 +593,9 @@ def parse_kernels(subparsers) -> None:
     parser_kernels_output_optional.add_argument(
         "-q", "--quiet", dest="quiet", action="store_true", required=False, help=Help.param_quiet
     )
+    parser_kernels_output_optional.add_argument(
+        "--file-pattern", dest="file_pattern", required=False, help=Help.param_kernel_output_file_pattern
+    )
     parser_kernels_output._action_groups.append(parser_kernels_output_optional)
     parser_kernels_output.set_defaults(func=api.kernels_output_cli)
 
@@ -1083,9 +1087,9 @@ class Help(object):
         + ", ".join(kernels_choices)
         + "}\nmodels {"
         + ", ".join(models_choices)
-        + "}\nmodels instances {"
+        + "}\nmodels variations {"
         + ", ".join(model_instances_choices)
-        + "}\nmodels instances versions {"
+        + "}\nmodels variations versions {"
         + ", ".join(model_instance_versions_choices)
         + "}\nconfig {"
         + ", ".join(config_choices)
@@ -1098,8 +1102,8 @@ class Help(object):
     group_datasets = "Commands related to Kaggle datasets"
     group_kernels = "Commands related to Kaggle kernels"
     group_models = "Commands related to Kaggle models"
-    group_model_instances = "Commands related to Kaggle model instances"
-    group_model_instance_versions = "Commands related to Kaggle model instance versions"
+    group_model_instances = "Commands related to Kaggle model variations"
+    group_model_instance_versions = "Commands related to Kaggle model variations versions"
     group_files = "Commands related files"
     group_config = "Configuration settings"
     group_auth = "Commands related to authentication"
@@ -1174,7 +1178,7 @@ class Help(object):
         "File for upload (full path), or the name of the output file produced by a kernel (for code competitions)"
     )
     param_code_kernel = "Name of kernel (notebook) to submit to a code competition"
-    param_code_version = 'Version of kernel to submit to a code competition, e.g. "Version 1"'
+    param_code_version = 'Version of kernel to submit to a code competition, e.g. "3"'
     param_csv = "Print results in CSV format (if not set print in table format)"
     param_page = "Page number for results paging. Page size is 20 by default"
     # NOTE: Default and max page size are set by the mid-tier code.
@@ -1226,7 +1230,7 @@ class Help(object):
     param_dataset_upfile = (
         "Folder for upload, containing data files and a "
         "special datasets-metadata.json file "
-        "(https://github.com/Kaggle/kaggle-api/wiki/Dataset-Metadata). "
+        "(https://github.com/Kaggle/kaggle-cli/blob/main/docs/datasets_metadata.md). "
         "Defaults to current working directory"
     )
     param_dataset_sort_by = (
@@ -1258,7 +1262,7 @@ class Help(object):
     param_kernel_upfile = (
         "Folder for upload, containing data files and a "
         "special kernel-metadata.json file "
-        "(https://github.com/Kaggle/kaggle-api/wiki/Kernel-Metadata). "
+        "(https://github.com/Kaggle/kaggle-cli/blob/main/docs/kernels_metadata.md). "
         "Defaults to current working directory"
     )
     param_kernel_parent = "Find children of the specified parent kernel"
@@ -1293,6 +1297,10 @@ class Help(object):
         "is only applicable if a search term is specified."
     )
     param_kernel_pull_metadata = "Generate metadata when pulling kernel"
+    param_kernel_output_file_pattern = (
+        "Regex pattern to match against filenames. Only files matching the pattern will be downloaded."
+    )
+    param_kernel_acc = "Specify the type of accelerator to use for the kernel run"
 
     # Models params
     param_model = "Model URL suffix in format <owner>/<model-name>"
@@ -1303,47 +1311,47 @@ class Help(object):
     param_model_owner = "Find public models owned by a specific user or organization"
     param_model_downfile = (
         "Folder containing the special model-metadata.json file "
-        "(https://github.com/Kaggle/kaggle-api/wiki/Model-Metadata)."
+        "(https://github.com/Kaggle/kaggle-cli/blob/main/docs/models_metadata.md)."
     )
     param_model_upfile = (
         "Folder containing the special model-metadata.json file "
-        "(https://github.com/Kaggle/kaggle-api/wiki/Model-Metadata). "
+        "(https://github.com/Kaggle/kaggle-cli/blob/main/docs/models_metadata.md). "
         "Defaults to current working directory"
     )
 
     # Model Instances params
-    param_model_instance = "Model Instance URL suffix in format <owner>/<model-name>/<framework>/<instance-slug>"
-    command_model_instances_get = "Get a model instance"
-    command_model_instances_init = "Initialize metadata file for model instance creation"
-    command_model_instances_files = "List files for the current version of a model instance"
-    command_model_instances_list = "List instances of a model"
-    command_model_instances_new = "Create a new model instance"
+    param_model_instance = "Model variation URL suffix in format <owner>/<model-name>/<framework>/<instance-slug>"
+    command_model_instances_get = "Get a model variation"
+    command_model_instances_init = "Initialize metadata file for model variation creation"
+    command_model_instances_files = "List files for the current version of a model variation"
+    command_model_instances_list = "List variations of a model"
+    command_model_instances_new = "Create a new model variation"
     param_model_instance_downfile = (
         "Folder for downloading the special model-instance-metadata.json file "
-        "(https://github.com/Kaggle/kaggle-api/wiki/Model-Metadata#model-instance). "
+        "(https://github.com/Kaggle/kaggle-cli/blob/main/docs/models_metadata.md#model-instance). "
     )
     param_model_instance_upfile = (
         "Folder for upload, containing data files and a "
         "special model-instance-metadata.json file "
-        "(https://github.com/Kaggle/kaggle-api/wiki/Model-Metadata#model-instance). "
+        "(https://github.com/Kaggle/kaggle-cli/blob/main/docs/models_metadata.md#model-instance). "
         "Defaults to current working directory"
     )
-    command_model_instances_delete = "Delete a model instance"
-    command_model_instances_update = "Update a model instance"
+    command_model_instances_delete = "Delete a model variation"
+    command_model_instances_update = "Update a model variation"
 
     # Model Instance Versions params
     param_model_instance_version = (
-        "Model Instance Version URL suffix in format <owner>/<model-name>/<framework>/<instance-slug>/<version-number>"
+        "Model variation version URL suffix in format <owner>/<model-name>/<framework>/<variation-slug>/<version-number>"
     )
 
     # Model Instance Versions params
-    command_model_instance_versions_new = "Create a new model instance version"
+    command_model_instance_versions_new = "Create a new model variation version"
     param_model_instance_version_upfile = "Folder for upload. Defaults to current working directory"
-    command_model_instance_versions_delete = "Delete a model instance version"
-    command_model_instance_versions_download = "Download model instance version files"
-    command_model_instance_versions_files = "List model instance version files"
-    command_model_instance_versions_list = "List model instance versions"
-    param_model_instance_version_notes = "Version notes to record for the new model instance version"
+    command_model_instance_versions_delete = "Delete a model variation version"
+    command_model_instance_versions_download = "Download model variation version files"
+    command_model_instance_versions_files = "List model variation version files"
+    command_model_instance_versions_list = "List model variation versions"
+    param_model_instance_version_notes = "Version notes to record for the new model variation version"
 
     # Files params
     param_files_upload_inbox_path = "Virtual path on the server where the uploaded files will be stored"

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.2.dist-info → kaggle-1.8.4.dist-info}/METADATA

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: kaggle
-Version: 1.8.2
+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
-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: setuptools>=21.0.0
-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-1.8.2.dist-info → kaggle-1.8.4.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.27.0
+Generator: hatchling 1.28.0
 Root-Is-Purelib: true
 Tag: py3-none-any

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