kaggle 1.6.12__tar.gz → 1.6.14__tar.gz

{kaggle-1.6.12/kaggle.egg-info → kaggle-1.6.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kaggle
-Version: 1.6.12
+Version: 1.6.14
 Summary: Kaggle API
 Home-page: https://github.com/Kaggle/kaggle-api
 Author: Kaggle

{kaggle-1.6.12 → kaggle-1.6.14}/README.md

@@ -16,12 +16,31 @@ pip install kaggle
 
 ## Development
 
+### Kaggle Internal
+
+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.
+However, do not try to create a release from within the container. The code formatter
+(`yapf3`) changes much more than intended.
+
+Also, run the following command to get `autogen.sh` installed:
+```bash
+rm -rf /tmp/autogen && mkdir -p /tmp/autogen && unzip -qo /tmp/autogen.zip -d /tmp/autogen &&
+mv /tmp/autogen/autogen-*/* /tmp/autogen && rm -rf /tmp/autogen/autogen-* &&
+sudo chmod a+rx /tmp/autogen/autogen.sh
+```
+
 ### Prerequisites
 
 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`.
+
 ### Dependencies
 
 ```sh

{kaggle-1.6.12 → kaggle-1.6.14}/kaggle/api/kaggle_api.py

@@ -407,6 +407,8 @@ class KaggleApi(object):
 
         :param async_req bool
         :param str id: Competition name (required)
+        :param str page_token: Page token for pagination
+        :param int page_size: Number of items per page (default 20)
         :return: Result
                  If the method is called asynchronously,
                  returns the request thread.
@@ -428,12 +430,14 @@ class KaggleApi(object):
 
         :param async_req bool
         :param str id: Competition name (required)
+        :param str page_token: Page token for pagination
+        :param int page_size: Number of items per page (default 20)
         :return: Result
                  If the method is called asynchronously,
                  returns the request thread.
         """
 
-        all_params = ['id']  # noqa: E501
+        all_params = ['id', 'page_token', 'page_size']  # noqa: E501
         all_params.append('async_req')
         all_params.append('_return_http_data_only')
         all_params.append('_preload_content')
@@ -460,6 +464,10 @@ class KaggleApi(object):
             path_params['id'] = params['id']  # noqa: E501
 
         query_params = []
+        if 'page_token' in params:
+            query_params.append(('pageToken', params['page_token']))  # noqa: E501
+        if 'page_size' in params:
+            query_params.append(('pageSize', params['page_size']))  # noqa: E501
 
         header_params = {}
 
@@ -1814,6 +1822,8 @@ class KaggleApi(object):
         :param str owner_slug: Dataset owner (required)
         :param str dataset_slug: Dataset name (required)
         :param str dataset_version_number: Dataset version number
+        :param str page_token: Page token for pagination
+        :param int page_size: Number of items per page (default 20)
         :return: Result
                  If the method is called asynchronously,
                  returns the request thread.
@@ -1837,12 +1847,14 @@ class KaggleApi(object):
         :param str owner_slug: Dataset owner (required)
         :param str dataset_slug: Dataset name (required)
         :param str dataset_version_number: Dataset version number
+        :param str page_token: Page token for pagination
+        :param int page_size: Number of items per page (default 20)
         :return: Result
                  If the method is called asynchronously,
                  returns the request thread.
         """
 
-        all_params = ['owner_slug', 'dataset_slug', 'dataset_version_number']  # noqa: E501
+        all_params = ['owner_slug', 'dataset_slug', 'dataset_version_number', 'page_token', 'page_size']  # noqa: E501
         all_params.append('async_req')
         all_params.append('_return_http_data_only')
         all_params.append('_preload_content')
@@ -1877,6 +1889,10 @@ class KaggleApi(object):
         query_params = []
         if 'dataset_version_number' in params:
             query_params.append(('datasetVersionNumber', params['dataset_version_number']))  # noqa: E501
+        if 'page_token' in params:
+            query_params.append(('pageToken', params['page_token']))  # noqa: E501
+        if 'page_size' in params:
+            query_params.append(('pageSize', params['page_size']))  # noqa: E501
 
         header_params = {}
 
@@ -2995,7 +3011,7 @@ class KaggleApi(object):
 
         :param async_req bool
         :param int page: Page number
-        :param int page_size: Page size
+        :param int page_size: Number of items per page (default 20)
         :param str search: Search terms
         :param str group: Display only your kernels
         :param str user: Display kernels by a particular group
@@ -3027,7 +3043,7 @@ class KaggleApi(object):
 
         :param async_req bool
         :param int page: Page number
-        :param int page_size: Page size
+        :param int page_size: Number of items per page (default 20)
         :param str search: Search terms
         :param str group: Display only your kernels
         :param str user: Display kernels by a particular group
@@ -3118,6 +3134,119 @@ class KaggleApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
+    def kernels_list_files(self, user_name, kernel_slug, **kwargs):  # noqa: E501
+        """List kernel files  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.kernels_list_files(user_name, kernel_slug, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param str user_name: Kernel owner (required)
+        :param str kernel_slug: Kernel name (required)
+        :param str kernel_version_number: Kernel version number
+        :param int page_size: Number of items per page (default 20)
+        :param str page_token: Page token for pagination
+        :return: Result
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.kernels_list_files_with_http_info(user_name, kernel_slug, **kwargs)  # noqa: E501
+        else:
+            (data) = self.kernels_list_files_with_http_info(user_name, kernel_slug, **kwargs)  # noqa: E501
+            return data
+
+    def kernels_list_files_with_http_info(self, user_name, kernel_slug, **kwargs):  # noqa: E501
+        """List kernel files  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.kernels_list_files_with_http_info(user_name, kernel_slug, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param str user_name: Kernel owner (required)
+        :param str kernel_slug: Kernel name (required)
+        :param str kernel_version_number: Kernel version number
+        :param int page_size: Number of items per page (default 20)
+        :param str page_token: Page token for pagination
+        :return: Result
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+
+        all_params = ['user_name', 'kernel_slug', 'kernel_version_number', 'page_size', 'page_token']  # noqa: E501
+        all_params.append('async_req')
+        all_params.append('_return_http_data_only')
+        all_params.append('_preload_content')
+        all_params.append('_request_timeout')
+
+        params = locals()
+        for key, val in six.iteritems(params['kwargs']):
+            if key not in all_params:
+                raise TypeError(
+                    "Got an unexpected keyword argument '%s'"
+                    " to method kernels_list_files" % key
+                )
+            params[key] = val
+        del params['kwargs']
+        # verify the required parameter 'user_name' is set
+        if ('user_name' not in params or
+                params['user_name'] is None):
+            raise ValueError("Missing the required parameter `user_name` when calling `kernels_list_files`")  # noqa: E501
+        # verify the required parameter 'kernel_slug' is set
+        if ('kernel_slug' not in params or
+                params['kernel_slug'] is None):
+            raise ValueError("Missing the required parameter `kernel_slug` when calling `kernels_list_files`")  # noqa: E501
+
+        collection_formats = {}
+
+        path_params = {}
+
+        query_params = []
+        if 'user_name' in params:
+            query_params.append(('userName', params['user_name']))  # noqa: E501
+        if 'kernel_slug' in params:
+            query_params.append(('kernelSlug', params['kernel_slug']))  # noqa: E501
+        if 'kernel_version_number' in params:
+            query_params.append(('kernelVersionNumber', params['kernel_version_number']))  # noqa: E501
+        if 'page_size' in params:
+            query_params.append(('pageSize', params['page_size']))  # noqa: E501
+        if 'page_token' in params:
+            query_params.append(('pageToken', params['page_token']))  # noqa: E501
+
+        header_params = {}
+
+        form_params = []
+        local_var_files = {}
+
+        body_params = None
+        # HTTP header `Accept`
+        header_params['Accept'] = self.api_client.select_header_accept(
+            ['application/json'])  # noqa: E501
+
+        # Authentication setting
+        auth_settings = ['basicAuth']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/kernels/files', 'GET',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='Result',  # noqa: E501
+            auth_settings=auth_settings,
+            async_req=params.get('async_req'),
+            _return_http_data_only=params.get('_return_http_data_only'),
+            _preload_content=params.get('_preload_content', True),
+            _request_timeout=params.get('_request_timeout'),
+            collection_formats=collection_formats)
+
     def metadata_get(self, owner_slug, dataset_slug, **kwargs):  # noqa: E501
         """Get the metadata for a dataset  # noqa: E501
 
@@ -3332,6 +3461,264 @@ class KaggleApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
+    def model_instance_files(self, owner_slug, model_slug, framework, instance_slug, **kwargs):  # noqa: E501
+        """List model instance files for the current version  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.model_instance_files(owner_slug, model_slug, framework, instance_slug, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param str owner_slug: Model owner (required)
+        :param str model_slug: Model name (required)
+        :param str framework: Model instance framework (required)
+        :param str instance_slug: Model instance slug (required)
+        :param int page_size: Number of items per page (default 20)
+        :param str page_token: Page token for pagination
+        :return: Result
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.model_instance_files_with_http_info(owner_slug, model_slug, framework, instance_slug, **kwargs)  # noqa: E501
+        else:
+            (data) = self.model_instance_files_with_http_info(owner_slug, model_slug, framework, instance_slug, **kwargs)  # noqa: E501
+            return data
+
+    def model_instance_files_with_http_info(self, owner_slug, model_slug, framework, instance_slug, **kwargs):  # noqa: E501
+        """List model instance files for the current version  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.model_instance_files_with_http_info(owner_slug, model_slug, framework, instance_slug, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param str owner_slug: Model owner (required)
+        :param str model_slug: Model name (required)
+        :param str framework: Model instance framework (required)
+        :param str instance_slug: Model instance slug (required)
+        :param int page_size: Number of items per page (default 20)
+        :param str page_token: Page token for pagination
+        :return: Result
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+
+        all_params = ['owner_slug', 'model_slug', 'framework', 'instance_slug', 'page_size', 'page_token']  # noqa: E501
+        all_params.append('async_req')
+        all_params.append('_return_http_data_only')
+        all_params.append('_preload_content')
+        all_params.append('_request_timeout')
+
+        params = locals()
+        for key, val in six.iteritems(params['kwargs']):
+            if key not in all_params:
+                raise TypeError(
+                    "Got an unexpected keyword argument '%s'"
+                    " to method model_instance_files" % key
+                )
+            params[key] = val
+        del params['kwargs']
+        # verify the required parameter 'owner_slug' is set
+        if ('owner_slug' not in params or
+                params['owner_slug'] is None):
+            raise ValueError("Missing the required parameter `owner_slug` when calling `model_instance_files`")  # noqa: E501
+        # verify the required parameter 'model_slug' is set
+        if ('model_slug' not in params or
+                params['model_slug'] is None):
+            raise ValueError("Missing the required parameter `model_slug` when calling `model_instance_files`")  # noqa: E501
+        # verify the required parameter 'framework' is set
+        if ('framework' not in params or
+                params['framework'] is None):
+            raise ValueError("Missing the required parameter `framework` when calling `model_instance_files`")  # noqa: E501
+        # verify the required parameter 'instance_slug' is set
+        if ('instance_slug' not in params or
+                params['instance_slug'] is None):
+            raise ValueError("Missing the required parameter `instance_slug` when calling `model_instance_files`")  # noqa: E501
+
+        collection_formats = {}
+
+        path_params = {}
+        if 'owner_slug' in params:
+            path_params['ownerSlug'] = params['owner_slug']  # noqa: E501
+        if 'model_slug' in params:
+            path_params['modelSlug'] = params['model_slug']  # noqa: E501
+        if 'framework' in params:
+            path_params['framework'] = params['framework']  # noqa: E501
+        if 'instance_slug' in params:
+            path_params['instanceSlug'] = params['instance_slug']  # noqa: E501
+
+        query_params = []
+        if 'page_size' in params:
+            query_params.append(('pageSize', params['page_size']))  # noqa: E501
+        if 'page_token' in params:
+            query_params.append(('pageToken', params['page_token']))  # noqa: E501
+
+        header_params = {}
+
+        form_params = []
+        local_var_files = {}
+
+        body_params = None
+        # HTTP header `Accept`
+        header_params['Accept'] = self.api_client.select_header_accept(
+            ['application/json'])  # noqa: E501
+
+        # Authentication setting
+        auth_settings = ['basicAuth']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/models/{ownerSlug}/{modelSlug}/{framework}/{instanceSlug}/files', 'GET',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='Result',  # noqa: E501
+            auth_settings=auth_settings,
+            async_req=params.get('async_req'),
+            _return_http_data_only=params.get('_return_http_data_only'),
+            _preload_content=params.get('_preload_content', True),
+            _request_timeout=params.get('_request_timeout'),
+            collection_formats=collection_formats)
+
+    def model_instance_version_files(self, owner_slug, model_slug, framework, instance_slug, version_number, **kwargs):  # noqa: E501
+        """List model instance version files  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.model_instance_version_files(owner_slug, model_slug, framework, instance_slug, version_number, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param str owner_slug: Model owner (required)
+        :param str model_slug: Model name (required)
+        :param str framework: Model instance framework (required)
+        :param str instance_slug: Model instance slug (required)
+        :param str version_number: Model instance version number (required)
+        :param int page_size: Number of items per page (default 20)
+        :param str page_token: Page token for pagination
+        :return: Result
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.model_instance_version_files_with_http_info(owner_slug, model_slug, framework, instance_slug, version_number, **kwargs)  # noqa: E501
+        else:
+            (data) = self.model_instance_version_files_with_http_info(owner_slug, model_slug, framework, instance_slug, version_number, **kwargs)  # noqa: E501
+            return data
+
+    def model_instance_version_files_with_http_info(self, owner_slug, model_slug, framework, instance_slug, version_number, **kwargs):  # noqa: E501
+        """List model instance version files  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.model_instance_version_files_with_http_info(owner_slug, model_slug, framework, instance_slug, version_number, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param str owner_slug: Model owner (required)
+        :param str model_slug: Model name (required)
+        :param str framework: Model instance framework (required)
+        :param str instance_slug: Model instance slug (required)
+        :param str version_number: Model instance version number (required)
+        :param int page_size: Number of items per page (default 20)
+        :param str page_token: Page token for pagination
+        :return: Result
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+
+        all_params = ['owner_slug', 'model_slug', 'framework', 'instance_slug', 'version_number', 'page_size', 'page_token']  # noqa: E501
+        all_params.append('async_req')
+        all_params.append('_return_http_data_only')
+        all_params.append('_preload_content')
+        all_params.append('_request_timeout')
+
+        params = locals()
+        for key, val in six.iteritems(params['kwargs']):
+            if key not in all_params:
+                raise TypeError(
+                    "Got an unexpected keyword argument '%s'"
+                    " to method model_instance_version_files" % key
+                )
+            params[key] = val
+        del params['kwargs']
+        # verify the required parameter 'owner_slug' is set
+        if ('owner_slug' not in params or
+                params['owner_slug'] is None):
+            raise ValueError("Missing the required parameter `owner_slug` when calling `model_instance_version_files`")  # noqa: E501
+        # verify the required parameter 'model_slug' is set
+        if ('model_slug' not in params or
+                params['model_slug'] is None):
+            raise ValueError("Missing the required parameter `model_slug` when calling `model_instance_version_files`")  # noqa: E501
+        # verify the required parameter 'framework' is set
+        if ('framework' not in params or
+                params['framework'] is None):
+            raise ValueError("Missing the required parameter `framework` when calling `model_instance_version_files`")  # noqa: E501
+        # verify the required parameter 'instance_slug' is set
+        if ('instance_slug' not in params or
+                params['instance_slug'] is None):
+            raise ValueError("Missing the required parameter `instance_slug` when calling `model_instance_version_files`")  # noqa: E501
+        # verify the required parameter 'version_number' is set
+        if ('version_number' not in params or
+                params['version_number'] is None):
+            raise ValueError("Missing the required parameter `version_number` when calling `model_instance_version_files`")  # noqa: E501
+
+        collection_formats = {}
+
+        path_params = {}
+        if 'owner_slug' in params:
+            path_params['ownerSlug'] = params['owner_slug']  # noqa: E501
+        if 'model_slug' in params:
+            path_params['modelSlug'] = params['model_slug']  # noqa: E501
+        if 'framework' in params:
+            path_params['framework'] = params['framework']  # noqa: E501
+        if 'instance_slug' in params:
+            path_params['instanceSlug'] = params['instance_slug']  # noqa: E501
+        if 'version_number' in params:
+            path_params['versionNumber'] = params['version_number']  # noqa: E501
+
+        query_params = []
+        if 'page_size' in params:
+            query_params.append(('pageSize', params['page_size']))  # noqa: E501
+        if 'page_token' in params:
+            query_params.append(('pageToken', params['page_token']))  # noqa: E501
+
+        header_params = {}
+
+        form_params = []
+        local_var_files = {}
+
+        body_params = None
+        # HTTP header `Accept`
+        header_params['Accept'] = self.api_client.select_header_accept(
+            ['application/json'])  # noqa: E501
+
+        # Authentication setting
+        auth_settings = ['basicAuth']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/models/{ownerSlug}/{modelSlug}/{framework}/{instanceSlug}/{versionNumber}/files', 'GET',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='Result',  # noqa: E501
+            auth_settings=auth_settings,
+            async_req=params.get('async_req'),
+            _return_http_data_only=params.get('_return_http_data_only'),
+            _preload_content=params.get('_preload_content', True),
+            _request_timeout=params.get('_request_timeout'),
+            collection_formats=collection_formats)
+
     def model_instance_versions_download(self, owner_slug, model_slug, framework, instance_slug, version_number, **kwargs):  # noqa: E501
         """Download model instance version files  # noqa: E501
 
@@ -3808,7 +4195,7 @@ class KaggleApi(object):
         :param str search: Search terms
         :param str sort_by: Sort the results
         :param str owner: Display models by a specific user or organization
-        :param int page_size: Page size
+        :param int page_size: Number of items per page (default 20)
         :param str page_token: Page token for pagination
         :return: Result
                  If the method is called asynchronously,
@@ -3833,7 +4220,7 @@ class KaggleApi(object):
         :param str search: Search terms
         :param str sort_by: Sort the results
         :param str owner: Display models by a specific user or organization
-        :param int page_size: Page size
+        :param int page_size: Number of items per page (default 20)
         :param str page_token: Page token for pagination
         :return: Result
                  If the method is called asynchronously,