5707 lines
257 KiB
Python
5707 lines
257 KiB
Python
# coding: utf-8
|
|
|
|
"""
|
|
Gitea API.
|
|
|
|
This documentation describes the Gitea API. # noqa: E501
|
|
|
|
OpenAPI spec version: 1.17.0+rc1
|
|
|
|
Generated by: https://github.com/swagger-api/swagger-codegen.git
|
|
"""
|
|
|
|
|
|
from __future__ import absolute_import
|
|
|
|
import re # noqa: F401
|
|
|
|
# python 2 and python 3 compatibility library
|
|
import six
|
|
|
|
from gitea.api_client import ApiClient
|
|
|
|
|
|
class IssueApi(object):
|
|
"""NOTE: This class is auto generated by the swagger code generator program.
|
|
|
|
Do not edit the class manually.
|
|
Ref: https://github.com/swagger-api/swagger-codegen
|
|
"""
|
|
|
|
def __init__(self, api_client=None):
|
|
if api_client is None:
|
|
api_client = ApiClient()
|
|
self.api_client = api_client
|
|
|
|
def issue_add_label(self, owner, repo, index, **kwargs): # noqa: E501
|
|
"""Add a label to an issue # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_add_label(owner, repo, index, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param int index: index of the issue (required)
|
|
:param IssueLabelsOption body:
|
|
:return: list[Label]
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
kwargs['_return_http_data_only'] = True
|
|
if kwargs.get('async_req'):
|
|
return self.issue_add_label_with_http_info(owner, repo, index, **kwargs) # noqa: E501
|
|
else:
|
|
(data) = self.issue_add_label_with_http_info(owner, repo, index, **kwargs) # noqa: E501
|
|
return data
|
|
|
|
def issue_add_label_with_http_info(self, owner, repo, index, **kwargs): # noqa: E501
|
|
"""Add a label to an issue # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_add_label_with_http_info(owner, repo, index, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param int index: index of the issue (required)
|
|
:param IssueLabelsOption body:
|
|
:return: list[Label]
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
|
|
all_params = ['owner', 'repo', 'index', 'body'] # 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 issue_add_label" % key
|
|
)
|
|
params[key] = val
|
|
del params['kwargs']
|
|
# verify the required parameter 'owner' is set
|
|
if self.api_client.client_side_validation and ('owner' not in params or
|
|
params['owner'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `owner` when calling `issue_add_label`") # noqa: E501
|
|
# verify the required parameter 'repo' is set
|
|
if self.api_client.client_side_validation and ('repo' not in params or
|
|
params['repo'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `repo` when calling `issue_add_label`") # noqa: E501
|
|
# verify the required parameter 'index' is set
|
|
if self.api_client.client_side_validation and ('index' not in params or
|
|
params['index'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `index` when calling `issue_add_label`") # noqa: E501
|
|
|
|
collection_formats = {}
|
|
|
|
path_params = {}
|
|
if 'owner' in params:
|
|
path_params['owner'] = params['owner'] # noqa: E501
|
|
if 'repo' in params:
|
|
path_params['repo'] = params['repo'] # noqa: E501
|
|
if 'index' in params:
|
|
path_params['index'] = params['index'] # noqa: E501
|
|
|
|
query_params = []
|
|
|
|
header_params = {}
|
|
|
|
form_params = []
|
|
local_var_files = {}
|
|
|
|
body_params = None
|
|
if 'body' in params:
|
|
body_params = params['body']
|
|
# HTTP header `Accept`
|
|
header_params['Accept'] = self.api_client.select_header_accept(
|
|
['application/json']) # noqa: E501
|
|
|
|
# HTTP header `Content-Type`
|
|
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
|
|
['application/json']) # noqa: E501
|
|
|
|
# Authentication setting
|
|
auth_settings = ['AccessToken', 'AuthorizationHeaderToken', 'BasicAuth', 'SudoHeader', 'SudoParam', 'TOTPHeader', 'Token'] # noqa: E501
|
|
|
|
return self.api_client.call_api(
|
|
'/repos/{owner}/{repo}/issues/{index}/labels', 'POST',
|
|
path_params,
|
|
query_params,
|
|
header_params,
|
|
body=body_params,
|
|
post_params=form_params,
|
|
files=local_var_files,
|
|
response_type='list[Label]', # 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 issue_add_subscription(self, owner, repo, index, user, **kwargs): # noqa: E501
|
|
"""Subscribe user to issue # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_add_subscription(owner, repo, index, user, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param int index: index of the issue (required)
|
|
:param str user: user to subscribe (required)
|
|
:return: None
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
kwargs['_return_http_data_only'] = True
|
|
if kwargs.get('async_req'):
|
|
return self.issue_add_subscription_with_http_info(owner, repo, index, user, **kwargs) # noqa: E501
|
|
else:
|
|
(data) = self.issue_add_subscription_with_http_info(owner, repo, index, user, **kwargs) # noqa: E501
|
|
return data
|
|
|
|
def issue_add_subscription_with_http_info(self, owner, repo, index, user, **kwargs): # noqa: E501
|
|
"""Subscribe user to issue # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_add_subscription_with_http_info(owner, repo, index, user, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param int index: index of the issue (required)
|
|
:param str user: user to subscribe (required)
|
|
:return: None
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
|
|
all_params = ['owner', 'repo', 'index', 'user'] # 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 issue_add_subscription" % key
|
|
)
|
|
params[key] = val
|
|
del params['kwargs']
|
|
# verify the required parameter 'owner' is set
|
|
if self.api_client.client_side_validation and ('owner' not in params or
|
|
params['owner'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `owner` when calling `issue_add_subscription`") # noqa: E501
|
|
# verify the required parameter 'repo' is set
|
|
if self.api_client.client_side_validation and ('repo' not in params or
|
|
params['repo'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `repo` when calling `issue_add_subscription`") # noqa: E501
|
|
# verify the required parameter 'index' is set
|
|
if self.api_client.client_side_validation and ('index' not in params or
|
|
params['index'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `index` when calling `issue_add_subscription`") # noqa: E501
|
|
# verify the required parameter 'user' is set
|
|
if self.api_client.client_side_validation and ('user' not in params or
|
|
params['user'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `user` when calling `issue_add_subscription`") # noqa: E501
|
|
|
|
collection_formats = {}
|
|
|
|
path_params = {}
|
|
if 'owner' in params:
|
|
path_params['owner'] = params['owner'] # noqa: E501
|
|
if 'repo' in params:
|
|
path_params['repo'] = params['repo'] # noqa: E501
|
|
if 'index' in params:
|
|
path_params['index'] = params['index'] # noqa: E501
|
|
if 'user' in params:
|
|
path_params['user'] = params['user'] # noqa: E501
|
|
|
|
query_params = []
|
|
|
|
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
|
|
|
|
# HTTP header `Content-Type`
|
|
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
|
|
['application/json']) # noqa: E501
|
|
|
|
# Authentication setting
|
|
auth_settings = ['AccessToken', 'AuthorizationHeaderToken', 'BasicAuth', 'SudoHeader', 'SudoParam', 'TOTPHeader', 'Token'] # noqa: E501
|
|
|
|
return self.api_client.call_api(
|
|
'/repos/{owner}/{repo}/issues/{index}/subscriptions/{user}', 'PUT',
|
|
path_params,
|
|
query_params,
|
|
header_params,
|
|
body=body_params,
|
|
post_params=form_params,
|
|
files=local_var_files,
|
|
response_type=None, # 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 issue_add_time(self, owner, repo, index, **kwargs): # noqa: E501
|
|
"""Add tracked time to a issue # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_add_time(owner, repo, index, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param int index: index of the issue (required)
|
|
:param AddTimeOption body:
|
|
:return: TrackedTime
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
kwargs['_return_http_data_only'] = True
|
|
if kwargs.get('async_req'):
|
|
return self.issue_add_time_with_http_info(owner, repo, index, **kwargs) # noqa: E501
|
|
else:
|
|
(data) = self.issue_add_time_with_http_info(owner, repo, index, **kwargs) # noqa: E501
|
|
return data
|
|
|
|
def issue_add_time_with_http_info(self, owner, repo, index, **kwargs): # noqa: E501
|
|
"""Add tracked time to a issue # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_add_time_with_http_info(owner, repo, index, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param int index: index of the issue (required)
|
|
:param AddTimeOption body:
|
|
:return: TrackedTime
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
|
|
all_params = ['owner', 'repo', 'index', 'body'] # 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 issue_add_time" % key
|
|
)
|
|
params[key] = val
|
|
del params['kwargs']
|
|
# verify the required parameter 'owner' is set
|
|
if self.api_client.client_side_validation and ('owner' not in params or
|
|
params['owner'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `owner` when calling `issue_add_time`") # noqa: E501
|
|
# verify the required parameter 'repo' is set
|
|
if self.api_client.client_side_validation and ('repo' not in params or
|
|
params['repo'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `repo` when calling `issue_add_time`") # noqa: E501
|
|
# verify the required parameter 'index' is set
|
|
if self.api_client.client_side_validation and ('index' not in params or
|
|
params['index'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `index` when calling `issue_add_time`") # noqa: E501
|
|
|
|
collection_formats = {}
|
|
|
|
path_params = {}
|
|
if 'owner' in params:
|
|
path_params['owner'] = params['owner'] # noqa: E501
|
|
if 'repo' in params:
|
|
path_params['repo'] = params['repo'] # noqa: E501
|
|
if 'index' in params:
|
|
path_params['index'] = params['index'] # noqa: E501
|
|
|
|
query_params = []
|
|
|
|
header_params = {}
|
|
|
|
form_params = []
|
|
local_var_files = {}
|
|
|
|
body_params = None
|
|
if 'body' in params:
|
|
body_params = params['body']
|
|
# HTTP header `Accept`
|
|
header_params['Accept'] = self.api_client.select_header_accept(
|
|
['application/json']) # noqa: E501
|
|
|
|
# HTTP header `Content-Type`
|
|
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
|
|
['application/json']) # noqa: E501
|
|
|
|
# Authentication setting
|
|
auth_settings = ['AccessToken', 'AuthorizationHeaderToken', 'BasicAuth', 'SudoHeader', 'SudoParam', 'TOTPHeader', 'Token'] # noqa: E501
|
|
|
|
return self.api_client.call_api(
|
|
'/repos/{owner}/{repo}/issues/{index}/times', 'POST',
|
|
path_params,
|
|
query_params,
|
|
header_params,
|
|
body=body_params,
|
|
post_params=form_params,
|
|
files=local_var_files,
|
|
response_type='TrackedTime', # 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 issue_check_subscription(self, owner, repo, index, **kwargs): # noqa: E501
|
|
"""Check if user is subscribed to an issue # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_check_subscription(owner, repo, index, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param int index: index of the issue (required)
|
|
:return: WatchInfo
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
kwargs['_return_http_data_only'] = True
|
|
if kwargs.get('async_req'):
|
|
return self.issue_check_subscription_with_http_info(owner, repo, index, **kwargs) # noqa: E501
|
|
else:
|
|
(data) = self.issue_check_subscription_with_http_info(owner, repo, index, **kwargs) # noqa: E501
|
|
return data
|
|
|
|
def issue_check_subscription_with_http_info(self, owner, repo, index, **kwargs): # noqa: E501
|
|
"""Check if user is subscribed to an issue # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_check_subscription_with_http_info(owner, repo, index, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param int index: index of the issue (required)
|
|
:return: WatchInfo
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
|
|
all_params = ['owner', 'repo', 'index'] # 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 issue_check_subscription" % key
|
|
)
|
|
params[key] = val
|
|
del params['kwargs']
|
|
# verify the required parameter 'owner' is set
|
|
if self.api_client.client_side_validation and ('owner' not in params or
|
|
params['owner'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `owner` when calling `issue_check_subscription`") # noqa: E501
|
|
# verify the required parameter 'repo' is set
|
|
if self.api_client.client_side_validation and ('repo' not in params or
|
|
params['repo'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `repo` when calling `issue_check_subscription`") # noqa: E501
|
|
# verify the required parameter 'index' is set
|
|
if self.api_client.client_side_validation and ('index' not in params or
|
|
params['index'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `index` when calling `issue_check_subscription`") # noqa: E501
|
|
|
|
collection_formats = {}
|
|
|
|
path_params = {}
|
|
if 'owner' in params:
|
|
path_params['owner'] = params['owner'] # noqa: E501
|
|
if 'repo' in params:
|
|
path_params['repo'] = params['repo'] # noqa: E501
|
|
if 'index' in params:
|
|
path_params['index'] = params['index'] # noqa: E501
|
|
|
|
query_params = []
|
|
|
|
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
|
|
|
|
# HTTP header `Content-Type`
|
|
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
|
|
['application/json']) # noqa: E501
|
|
|
|
# Authentication setting
|
|
auth_settings = ['AccessToken', 'AuthorizationHeaderToken', 'BasicAuth', 'SudoHeader', 'SudoParam', 'TOTPHeader', 'Token'] # noqa: E501
|
|
|
|
return self.api_client.call_api(
|
|
'/repos/{owner}/{repo}/issues/{index}/subscriptions/check', 'GET',
|
|
path_params,
|
|
query_params,
|
|
header_params,
|
|
body=body_params,
|
|
post_params=form_params,
|
|
files=local_var_files,
|
|
response_type='WatchInfo', # 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 issue_clear_labels(self, owner, repo, index, **kwargs): # noqa: E501
|
|
"""Remove all labels from an issue # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_clear_labels(owner, repo, index, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param int index: index of the issue (required)
|
|
:return: None
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
kwargs['_return_http_data_only'] = True
|
|
if kwargs.get('async_req'):
|
|
return self.issue_clear_labels_with_http_info(owner, repo, index, **kwargs) # noqa: E501
|
|
else:
|
|
(data) = self.issue_clear_labels_with_http_info(owner, repo, index, **kwargs) # noqa: E501
|
|
return data
|
|
|
|
def issue_clear_labels_with_http_info(self, owner, repo, index, **kwargs): # noqa: E501
|
|
"""Remove all labels from an issue # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_clear_labels_with_http_info(owner, repo, index, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param int index: index of the issue (required)
|
|
:return: None
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
|
|
all_params = ['owner', 'repo', 'index'] # 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 issue_clear_labels" % key
|
|
)
|
|
params[key] = val
|
|
del params['kwargs']
|
|
# verify the required parameter 'owner' is set
|
|
if self.api_client.client_side_validation and ('owner' not in params or
|
|
params['owner'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `owner` when calling `issue_clear_labels`") # noqa: E501
|
|
# verify the required parameter 'repo' is set
|
|
if self.api_client.client_side_validation and ('repo' not in params or
|
|
params['repo'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `repo` when calling `issue_clear_labels`") # noqa: E501
|
|
# verify the required parameter 'index' is set
|
|
if self.api_client.client_side_validation and ('index' not in params or
|
|
params['index'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `index` when calling `issue_clear_labels`") # noqa: E501
|
|
|
|
collection_formats = {}
|
|
|
|
path_params = {}
|
|
if 'owner' in params:
|
|
path_params['owner'] = params['owner'] # noqa: E501
|
|
if 'repo' in params:
|
|
path_params['repo'] = params['repo'] # noqa: E501
|
|
if 'index' in params:
|
|
path_params['index'] = params['index'] # noqa: E501
|
|
|
|
query_params = []
|
|
|
|
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
|
|
|
|
# HTTP header `Content-Type`
|
|
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
|
|
['application/json', 'text/plain']) # noqa: E501
|
|
|
|
# Authentication setting
|
|
auth_settings = ['AccessToken', 'AuthorizationHeaderToken', 'BasicAuth', 'SudoHeader', 'SudoParam', 'TOTPHeader', 'Token'] # noqa: E501
|
|
|
|
return self.api_client.call_api(
|
|
'/repos/{owner}/{repo}/issues/{index}/labels', 'DELETE',
|
|
path_params,
|
|
query_params,
|
|
header_params,
|
|
body=body_params,
|
|
post_params=form_params,
|
|
files=local_var_files,
|
|
response_type=None, # 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 issue_create_comment(self, owner, repo, index, **kwargs): # noqa: E501
|
|
"""Add a comment to an issue # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_create_comment(owner, repo, index, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param int index: index of the issue (required)
|
|
:param CreateIssueCommentOption body:
|
|
:return: Comment
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
kwargs['_return_http_data_only'] = True
|
|
if kwargs.get('async_req'):
|
|
return self.issue_create_comment_with_http_info(owner, repo, index, **kwargs) # noqa: E501
|
|
else:
|
|
(data) = self.issue_create_comment_with_http_info(owner, repo, index, **kwargs) # noqa: E501
|
|
return data
|
|
|
|
def issue_create_comment_with_http_info(self, owner, repo, index, **kwargs): # noqa: E501
|
|
"""Add a comment to an issue # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_create_comment_with_http_info(owner, repo, index, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param int index: index of the issue (required)
|
|
:param CreateIssueCommentOption body:
|
|
:return: Comment
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
|
|
all_params = ['owner', 'repo', 'index', 'body'] # 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 issue_create_comment" % key
|
|
)
|
|
params[key] = val
|
|
del params['kwargs']
|
|
# verify the required parameter 'owner' is set
|
|
if self.api_client.client_side_validation and ('owner' not in params or
|
|
params['owner'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `owner` when calling `issue_create_comment`") # noqa: E501
|
|
# verify the required parameter 'repo' is set
|
|
if self.api_client.client_side_validation and ('repo' not in params or
|
|
params['repo'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `repo` when calling `issue_create_comment`") # noqa: E501
|
|
# verify the required parameter 'index' is set
|
|
if self.api_client.client_side_validation and ('index' not in params or
|
|
params['index'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `index` when calling `issue_create_comment`") # noqa: E501
|
|
|
|
collection_formats = {}
|
|
|
|
path_params = {}
|
|
if 'owner' in params:
|
|
path_params['owner'] = params['owner'] # noqa: E501
|
|
if 'repo' in params:
|
|
path_params['repo'] = params['repo'] # noqa: E501
|
|
if 'index' in params:
|
|
path_params['index'] = params['index'] # noqa: E501
|
|
|
|
query_params = []
|
|
|
|
header_params = {}
|
|
|
|
form_params = []
|
|
local_var_files = {}
|
|
|
|
body_params = None
|
|
if 'body' in params:
|
|
body_params = params['body']
|
|
# HTTP header `Accept`
|
|
header_params['Accept'] = self.api_client.select_header_accept(
|
|
['application/json']) # noqa: E501
|
|
|
|
# HTTP header `Content-Type`
|
|
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
|
|
['application/json']) # noqa: E501
|
|
|
|
# Authentication setting
|
|
auth_settings = ['AccessToken', 'AuthorizationHeaderToken', 'BasicAuth', 'SudoHeader', 'SudoParam', 'TOTPHeader', 'Token'] # noqa: E501
|
|
|
|
return self.api_client.call_api(
|
|
'/repos/{owner}/{repo}/issues/{index}/comments', 'POST',
|
|
path_params,
|
|
query_params,
|
|
header_params,
|
|
body=body_params,
|
|
post_params=form_params,
|
|
files=local_var_files,
|
|
response_type='Comment', # 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 issue_create_issue(self, owner, repo, **kwargs): # noqa: E501
|
|
"""Create an issue. If using deadline only the date will be taken into account, and time of day ignored. # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_create_issue(owner, repo, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param CreateIssueOption body:
|
|
:return: Issue
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
kwargs['_return_http_data_only'] = True
|
|
if kwargs.get('async_req'):
|
|
return self.issue_create_issue_with_http_info(owner, repo, **kwargs) # noqa: E501
|
|
else:
|
|
(data) = self.issue_create_issue_with_http_info(owner, repo, **kwargs) # noqa: E501
|
|
return data
|
|
|
|
def issue_create_issue_with_http_info(self, owner, repo, **kwargs): # noqa: E501
|
|
"""Create an issue. If using deadline only the date will be taken into account, and time of day ignored. # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_create_issue_with_http_info(owner, repo, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param CreateIssueOption body:
|
|
:return: Issue
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
|
|
all_params = ['owner', 'repo', 'body'] # 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 issue_create_issue" % key
|
|
)
|
|
params[key] = val
|
|
del params['kwargs']
|
|
# verify the required parameter 'owner' is set
|
|
if self.api_client.client_side_validation and ('owner' not in params or
|
|
params['owner'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `owner` when calling `issue_create_issue`") # noqa: E501
|
|
# verify the required parameter 'repo' is set
|
|
if self.api_client.client_side_validation and ('repo' not in params or
|
|
params['repo'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `repo` when calling `issue_create_issue`") # noqa: E501
|
|
|
|
collection_formats = {}
|
|
|
|
path_params = {}
|
|
if 'owner' in params:
|
|
path_params['owner'] = params['owner'] # noqa: E501
|
|
if 'repo' in params:
|
|
path_params['repo'] = params['repo'] # noqa: E501
|
|
|
|
query_params = []
|
|
|
|
header_params = {}
|
|
|
|
form_params = []
|
|
local_var_files = {}
|
|
|
|
body_params = None
|
|
if 'body' in params:
|
|
body_params = params['body']
|
|
# HTTP header `Accept`
|
|
header_params['Accept'] = self.api_client.select_header_accept(
|
|
['application/json']) # noqa: E501
|
|
|
|
# HTTP header `Content-Type`
|
|
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
|
|
['application/json']) # noqa: E501
|
|
|
|
# Authentication setting
|
|
auth_settings = ['AccessToken', 'AuthorizationHeaderToken', 'BasicAuth', 'SudoHeader', 'SudoParam', 'TOTPHeader', 'Token'] # noqa: E501
|
|
|
|
return self.api_client.call_api(
|
|
'/repos/{owner}/{repo}/issues', 'POST',
|
|
path_params,
|
|
query_params,
|
|
header_params,
|
|
body=body_params,
|
|
post_params=form_params,
|
|
files=local_var_files,
|
|
response_type='Issue', # 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 issue_create_label(self, owner, repo, **kwargs): # noqa: E501
|
|
"""Create a label # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_create_label(owner, repo, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param CreateLabelOption body:
|
|
:return: Label
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
kwargs['_return_http_data_only'] = True
|
|
if kwargs.get('async_req'):
|
|
return self.issue_create_label_with_http_info(owner, repo, **kwargs) # noqa: E501
|
|
else:
|
|
(data) = self.issue_create_label_with_http_info(owner, repo, **kwargs) # noqa: E501
|
|
return data
|
|
|
|
def issue_create_label_with_http_info(self, owner, repo, **kwargs): # noqa: E501
|
|
"""Create a label # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_create_label_with_http_info(owner, repo, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param CreateLabelOption body:
|
|
:return: Label
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
|
|
all_params = ['owner', 'repo', 'body'] # 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 issue_create_label" % key
|
|
)
|
|
params[key] = val
|
|
del params['kwargs']
|
|
# verify the required parameter 'owner' is set
|
|
if self.api_client.client_side_validation and ('owner' not in params or
|
|
params['owner'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `owner` when calling `issue_create_label`") # noqa: E501
|
|
# verify the required parameter 'repo' is set
|
|
if self.api_client.client_side_validation and ('repo' not in params or
|
|
params['repo'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `repo` when calling `issue_create_label`") # noqa: E501
|
|
|
|
collection_formats = {}
|
|
|
|
path_params = {}
|
|
if 'owner' in params:
|
|
path_params['owner'] = params['owner'] # noqa: E501
|
|
if 'repo' in params:
|
|
path_params['repo'] = params['repo'] # noqa: E501
|
|
|
|
query_params = []
|
|
|
|
header_params = {}
|
|
|
|
form_params = []
|
|
local_var_files = {}
|
|
|
|
body_params = None
|
|
if 'body' in params:
|
|
body_params = params['body']
|
|
# HTTP header `Accept`
|
|
header_params['Accept'] = self.api_client.select_header_accept(
|
|
['application/json']) # noqa: E501
|
|
|
|
# HTTP header `Content-Type`
|
|
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
|
|
['application/json']) # noqa: E501
|
|
|
|
# Authentication setting
|
|
auth_settings = ['AccessToken', 'AuthorizationHeaderToken', 'BasicAuth', 'SudoHeader', 'SudoParam', 'TOTPHeader', 'Token'] # noqa: E501
|
|
|
|
return self.api_client.call_api(
|
|
'/repos/{owner}/{repo}/labels', 'POST',
|
|
path_params,
|
|
query_params,
|
|
header_params,
|
|
body=body_params,
|
|
post_params=form_params,
|
|
files=local_var_files,
|
|
response_type='Label', # 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 issue_create_milestone(self, owner, repo, **kwargs): # noqa: E501
|
|
"""Create a milestone # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_create_milestone(owner, repo, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param CreateMilestoneOption body:
|
|
:return: Milestone
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
kwargs['_return_http_data_only'] = True
|
|
if kwargs.get('async_req'):
|
|
return self.issue_create_milestone_with_http_info(owner, repo, **kwargs) # noqa: E501
|
|
else:
|
|
(data) = self.issue_create_milestone_with_http_info(owner, repo, **kwargs) # noqa: E501
|
|
return data
|
|
|
|
def issue_create_milestone_with_http_info(self, owner, repo, **kwargs): # noqa: E501
|
|
"""Create a milestone # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_create_milestone_with_http_info(owner, repo, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param CreateMilestoneOption body:
|
|
:return: Milestone
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
|
|
all_params = ['owner', 'repo', 'body'] # 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 issue_create_milestone" % key
|
|
)
|
|
params[key] = val
|
|
del params['kwargs']
|
|
# verify the required parameter 'owner' is set
|
|
if self.api_client.client_side_validation and ('owner' not in params or
|
|
params['owner'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `owner` when calling `issue_create_milestone`") # noqa: E501
|
|
# verify the required parameter 'repo' is set
|
|
if self.api_client.client_side_validation and ('repo' not in params or
|
|
params['repo'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `repo` when calling `issue_create_milestone`") # noqa: E501
|
|
|
|
collection_formats = {}
|
|
|
|
path_params = {}
|
|
if 'owner' in params:
|
|
path_params['owner'] = params['owner'] # noqa: E501
|
|
if 'repo' in params:
|
|
path_params['repo'] = params['repo'] # noqa: E501
|
|
|
|
query_params = []
|
|
|
|
header_params = {}
|
|
|
|
form_params = []
|
|
local_var_files = {}
|
|
|
|
body_params = None
|
|
if 'body' in params:
|
|
body_params = params['body']
|
|
# HTTP header `Accept`
|
|
header_params['Accept'] = self.api_client.select_header_accept(
|
|
['application/json']) # noqa: E501
|
|
|
|
# HTTP header `Content-Type`
|
|
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
|
|
['application/json']) # noqa: E501
|
|
|
|
# Authentication setting
|
|
auth_settings = ['AccessToken', 'AuthorizationHeaderToken', 'BasicAuth', 'SudoHeader', 'SudoParam', 'TOTPHeader', 'Token'] # noqa: E501
|
|
|
|
return self.api_client.call_api(
|
|
'/repos/{owner}/{repo}/milestones', 'POST',
|
|
path_params,
|
|
query_params,
|
|
header_params,
|
|
body=body_params,
|
|
post_params=form_params,
|
|
files=local_var_files,
|
|
response_type='Milestone', # 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 issue_delete(self, owner, repo, index, **kwargs): # noqa: E501
|
|
"""Delete an issue # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_delete(owner, repo, index, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param int index: index of issue to delete (required)
|
|
:return: None
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
kwargs['_return_http_data_only'] = True
|
|
if kwargs.get('async_req'):
|
|
return self.issue_delete_with_http_info(owner, repo, index, **kwargs) # noqa: E501
|
|
else:
|
|
(data) = self.issue_delete_with_http_info(owner, repo, index, **kwargs) # noqa: E501
|
|
return data
|
|
|
|
def issue_delete_with_http_info(self, owner, repo, index, **kwargs): # noqa: E501
|
|
"""Delete an issue # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_delete_with_http_info(owner, repo, index, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param int index: index of issue to delete (required)
|
|
:return: None
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
|
|
all_params = ['owner', 'repo', 'index'] # 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 issue_delete" % key
|
|
)
|
|
params[key] = val
|
|
del params['kwargs']
|
|
# verify the required parameter 'owner' is set
|
|
if self.api_client.client_side_validation and ('owner' not in params or
|
|
params['owner'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `owner` when calling `issue_delete`") # noqa: E501
|
|
# verify the required parameter 'repo' is set
|
|
if self.api_client.client_side_validation and ('repo' not in params or
|
|
params['repo'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `repo` when calling `issue_delete`") # noqa: E501
|
|
# verify the required parameter 'index' is set
|
|
if self.api_client.client_side_validation and ('index' not in params or
|
|
params['index'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `index` when calling `issue_delete`") # noqa: E501
|
|
|
|
collection_formats = {}
|
|
|
|
path_params = {}
|
|
if 'owner' in params:
|
|
path_params['owner'] = params['owner'] # noqa: E501
|
|
if 'repo' in params:
|
|
path_params['repo'] = params['repo'] # noqa: E501
|
|
if 'index' in params:
|
|
path_params['index'] = params['index'] # noqa: E501
|
|
|
|
query_params = []
|
|
|
|
header_params = {}
|
|
|
|
form_params = []
|
|
local_var_files = {}
|
|
|
|
body_params = None
|
|
# HTTP header `Accept`
|
|
header_params['Accept'] = self.api_client.select_header_accept(
|
|
['application/json', 'text/html']) # noqa: E501
|
|
|
|
# HTTP header `Content-Type`
|
|
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
|
|
['application/json', 'text/plain']) # noqa: E501
|
|
|
|
# Authentication setting
|
|
auth_settings = ['AccessToken', 'AuthorizationHeaderToken', 'BasicAuth', 'SudoHeader', 'SudoParam', 'TOTPHeader', 'Token'] # noqa: E501
|
|
|
|
return self.api_client.call_api(
|
|
'/repos/{owner}/{repo}/issues/{index}', 'DELETE',
|
|
path_params,
|
|
query_params,
|
|
header_params,
|
|
body=body_params,
|
|
post_params=form_params,
|
|
files=local_var_files,
|
|
response_type=None, # 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 issue_delete_comment(self, owner, repo, id, **kwargs): # noqa: E501
|
|
"""Delete a comment # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_delete_comment(owner, repo, id, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param int id: id of comment to delete (required)
|
|
:return: None
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
kwargs['_return_http_data_only'] = True
|
|
if kwargs.get('async_req'):
|
|
return self.issue_delete_comment_with_http_info(owner, repo, id, **kwargs) # noqa: E501
|
|
else:
|
|
(data) = self.issue_delete_comment_with_http_info(owner, repo, id, **kwargs) # noqa: E501
|
|
return data
|
|
|
|
def issue_delete_comment_with_http_info(self, owner, repo, id, **kwargs): # noqa: E501
|
|
"""Delete a comment # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_delete_comment_with_http_info(owner, repo, id, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param int id: id of comment to delete (required)
|
|
:return: None
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
|
|
all_params = ['owner', 'repo', 'id'] # 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 issue_delete_comment" % key
|
|
)
|
|
params[key] = val
|
|
del params['kwargs']
|
|
# verify the required parameter 'owner' is set
|
|
if self.api_client.client_side_validation and ('owner' not in params or
|
|
params['owner'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `owner` when calling `issue_delete_comment`") # noqa: E501
|
|
# verify the required parameter 'repo' is set
|
|
if self.api_client.client_side_validation and ('repo' not in params or
|
|
params['repo'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `repo` when calling `issue_delete_comment`") # noqa: E501
|
|
# verify the required parameter 'id' is set
|
|
if self.api_client.client_side_validation and ('id' not in params or
|
|
params['id'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `id` when calling `issue_delete_comment`") # noqa: E501
|
|
|
|
collection_formats = {}
|
|
|
|
path_params = {}
|
|
if 'owner' in params:
|
|
path_params['owner'] = params['owner'] # noqa: E501
|
|
if 'repo' in params:
|
|
path_params['repo'] = params['repo'] # noqa: E501
|
|
if 'id' in params:
|
|
path_params['id'] = params['id'] # noqa: E501
|
|
|
|
query_params = []
|
|
|
|
header_params = {}
|
|
|
|
form_params = []
|
|
local_var_files = {}
|
|
|
|
body_params = None
|
|
# HTTP header `Accept`
|
|
header_params['Accept'] = self.api_client.select_header_accept(
|
|
['application/json', 'text/html']) # noqa: E501
|
|
|
|
# HTTP header `Content-Type`
|
|
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
|
|
['application/json', 'text/plain']) # noqa: E501
|
|
|
|
# Authentication setting
|
|
auth_settings = ['AccessToken', 'AuthorizationHeaderToken', 'BasicAuth', 'SudoHeader', 'SudoParam', 'TOTPHeader', 'Token'] # noqa: E501
|
|
|
|
return self.api_client.call_api(
|
|
'/repos/{owner}/{repo}/issues/comments/{id}', 'DELETE',
|
|
path_params,
|
|
query_params,
|
|
header_params,
|
|
body=body_params,
|
|
post_params=form_params,
|
|
files=local_var_files,
|
|
response_type=None, # 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 issue_delete_comment_deprecated(self, owner, repo, index, id, **kwargs): # noqa: E501
|
|
"""Delete a comment # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_delete_comment_deprecated(owner, repo, index, id, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param int index: this parameter is ignored (required)
|
|
:param int id: id of comment to delete (required)
|
|
:return: None
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
kwargs['_return_http_data_only'] = True
|
|
if kwargs.get('async_req'):
|
|
return self.issue_delete_comment_deprecated_with_http_info(owner, repo, index, id, **kwargs) # noqa: E501
|
|
else:
|
|
(data) = self.issue_delete_comment_deprecated_with_http_info(owner, repo, index, id, **kwargs) # noqa: E501
|
|
return data
|
|
|
|
def issue_delete_comment_deprecated_with_http_info(self, owner, repo, index, id, **kwargs): # noqa: E501
|
|
"""Delete a comment # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_delete_comment_deprecated_with_http_info(owner, repo, index, id, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param int index: this parameter is ignored (required)
|
|
:param int id: id of comment to delete (required)
|
|
:return: None
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
|
|
all_params = ['owner', 'repo', 'index', 'id'] # 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 issue_delete_comment_deprecated" % key
|
|
)
|
|
params[key] = val
|
|
del params['kwargs']
|
|
# verify the required parameter 'owner' is set
|
|
if self.api_client.client_side_validation and ('owner' not in params or
|
|
params['owner'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `owner` when calling `issue_delete_comment_deprecated`") # noqa: E501
|
|
# verify the required parameter 'repo' is set
|
|
if self.api_client.client_side_validation and ('repo' not in params or
|
|
params['repo'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `repo` when calling `issue_delete_comment_deprecated`") # noqa: E501
|
|
# verify the required parameter 'index' is set
|
|
if self.api_client.client_side_validation and ('index' not in params or
|
|
params['index'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `index` when calling `issue_delete_comment_deprecated`") # noqa: E501
|
|
# verify the required parameter 'id' is set
|
|
if self.api_client.client_side_validation and ('id' not in params or
|
|
params['id'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `id` when calling `issue_delete_comment_deprecated`") # noqa: E501
|
|
|
|
collection_formats = {}
|
|
|
|
path_params = {}
|
|
if 'owner' in params:
|
|
path_params['owner'] = params['owner'] # noqa: E501
|
|
if 'repo' in params:
|
|
path_params['repo'] = params['repo'] # noqa: E501
|
|
if 'index' in params:
|
|
path_params['index'] = params['index'] # noqa: E501
|
|
if 'id' in params:
|
|
path_params['id'] = params['id'] # noqa: E501
|
|
|
|
query_params = []
|
|
|
|
header_params = {}
|
|
|
|
form_params = []
|
|
local_var_files = {}
|
|
|
|
body_params = None
|
|
# HTTP header `Accept`
|
|
header_params['Accept'] = self.api_client.select_header_accept(
|
|
['application/json', 'text/html']) # noqa: E501
|
|
|
|
# HTTP header `Content-Type`
|
|
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
|
|
['application/json', 'text/plain']) # noqa: E501
|
|
|
|
# Authentication setting
|
|
auth_settings = ['AccessToken', 'AuthorizationHeaderToken', 'BasicAuth', 'SudoHeader', 'SudoParam', 'TOTPHeader', 'Token'] # noqa: E501
|
|
|
|
return self.api_client.call_api(
|
|
'/repos/{owner}/{repo}/issues/{index}/comments/{id}', 'DELETE',
|
|
path_params,
|
|
query_params,
|
|
header_params,
|
|
body=body_params,
|
|
post_params=form_params,
|
|
files=local_var_files,
|
|
response_type=None, # 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 issue_delete_comment_reaction(self, owner, repo, id, **kwargs): # noqa: E501
|
|
"""Remove a reaction from a comment of an issue # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_delete_comment_reaction(owner, repo, id, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param int id: id of the comment to edit (required)
|
|
:param EditReactionOption content:
|
|
:return: None
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
kwargs['_return_http_data_only'] = True
|
|
if kwargs.get('async_req'):
|
|
return self.issue_delete_comment_reaction_with_http_info(owner, repo, id, **kwargs) # noqa: E501
|
|
else:
|
|
(data) = self.issue_delete_comment_reaction_with_http_info(owner, repo, id, **kwargs) # noqa: E501
|
|
return data
|
|
|
|
def issue_delete_comment_reaction_with_http_info(self, owner, repo, id, **kwargs): # noqa: E501
|
|
"""Remove a reaction from a comment of an issue # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_delete_comment_reaction_with_http_info(owner, repo, id, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param int id: id of the comment to edit (required)
|
|
:param EditReactionOption content:
|
|
:return: None
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
|
|
all_params = ['owner', 'repo', 'id', 'content'] # 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 issue_delete_comment_reaction" % key
|
|
)
|
|
params[key] = val
|
|
del params['kwargs']
|
|
# verify the required parameter 'owner' is set
|
|
if self.api_client.client_side_validation and ('owner' not in params or
|
|
params['owner'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `owner` when calling `issue_delete_comment_reaction`") # noqa: E501
|
|
# verify the required parameter 'repo' is set
|
|
if self.api_client.client_side_validation and ('repo' not in params or
|
|
params['repo'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `repo` when calling `issue_delete_comment_reaction`") # noqa: E501
|
|
# verify the required parameter 'id' is set
|
|
if self.api_client.client_side_validation and ('id' not in params or
|
|
params['id'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `id` when calling `issue_delete_comment_reaction`") # noqa: E501
|
|
|
|
collection_formats = {}
|
|
|
|
path_params = {}
|
|
if 'owner' in params:
|
|
path_params['owner'] = params['owner'] # noqa: E501
|
|
if 'repo' in params:
|
|
path_params['repo'] = params['repo'] # noqa: E501
|
|
if 'id' in params:
|
|
path_params['id'] = params['id'] # noqa: E501
|
|
|
|
query_params = []
|
|
|
|
header_params = {}
|
|
|
|
form_params = []
|
|
local_var_files = {}
|
|
|
|
body_params = None
|
|
if 'content' in params:
|
|
body_params = params['content']
|
|
# HTTP header `Accept`
|
|
header_params['Accept'] = self.api_client.select_header_accept(
|
|
['application/json']) # noqa: E501
|
|
|
|
# HTTP header `Content-Type`
|
|
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
|
|
['application/json']) # noqa: E501
|
|
|
|
# Authentication setting
|
|
auth_settings = ['AccessToken', 'AuthorizationHeaderToken', 'BasicAuth', 'SudoHeader', 'SudoParam', 'TOTPHeader', 'Token'] # noqa: E501
|
|
|
|
return self.api_client.call_api(
|
|
'/repos/{owner}/{repo}/issues/comments/{id}/reactions', 'DELETE',
|
|
path_params,
|
|
query_params,
|
|
header_params,
|
|
body=body_params,
|
|
post_params=form_params,
|
|
files=local_var_files,
|
|
response_type=None, # 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 issue_delete_issue_reaction(self, owner, repo, index, **kwargs): # noqa: E501
|
|
"""Remove a reaction from an issue # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_delete_issue_reaction(owner, repo, index, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param int index: index of the issue (required)
|
|
:param EditReactionOption content:
|
|
:return: None
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
kwargs['_return_http_data_only'] = True
|
|
if kwargs.get('async_req'):
|
|
return self.issue_delete_issue_reaction_with_http_info(owner, repo, index, **kwargs) # noqa: E501
|
|
else:
|
|
(data) = self.issue_delete_issue_reaction_with_http_info(owner, repo, index, **kwargs) # noqa: E501
|
|
return data
|
|
|
|
def issue_delete_issue_reaction_with_http_info(self, owner, repo, index, **kwargs): # noqa: E501
|
|
"""Remove a reaction from an issue # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_delete_issue_reaction_with_http_info(owner, repo, index, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param int index: index of the issue (required)
|
|
:param EditReactionOption content:
|
|
:return: None
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
|
|
all_params = ['owner', 'repo', 'index', 'content'] # 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 issue_delete_issue_reaction" % key
|
|
)
|
|
params[key] = val
|
|
del params['kwargs']
|
|
# verify the required parameter 'owner' is set
|
|
if self.api_client.client_side_validation and ('owner' not in params or
|
|
params['owner'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `owner` when calling `issue_delete_issue_reaction`") # noqa: E501
|
|
# verify the required parameter 'repo' is set
|
|
if self.api_client.client_side_validation and ('repo' not in params or
|
|
params['repo'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `repo` when calling `issue_delete_issue_reaction`") # noqa: E501
|
|
# verify the required parameter 'index' is set
|
|
if self.api_client.client_side_validation and ('index' not in params or
|
|
params['index'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `index` when calling `issue_delete_issue_reaction`") # noqa: E501
|
|
|
|
collection_formats = {}
|
|
|
|
path_params = {}
|
|
if 'owner' in params:
|
|
path_params['owner'] = params['owner'] # noqa: E501
|
|
if 'repo' in params:
|
|
path_params['repo'] = params['repo'] # noqa: E501
|
|
if 'index' in params:
|
|
path_params['index'] = params['index'] # noqa: E501
|
|
|
|
query_params = []
|
|
|
|
header_params = {}
|
|
|
|
form_params = []
|
|
local_var_files = {}
|
|
|
|
body_params = None
|
|
if 'content' in params:
|
|
body_params = params['content']
|
|
# HTTP header `Accept`
|
|
header_params['Accept'] = self.api_client.select_header_accept(
|
|
['application/json']) # noqa: E501
|
|
|
|
# HTTP header `Content-Type`
|
|
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
|
|
['application/json']) # noqa: E501
|
|
|
|
# Authentication setting
|
|
auth_settings = ['AccessToken', 'AuthorizationHeaderToken', 'BasicAuth', 'SudoHeader', 'SudoParam', 'TOTPHeader', 'Token'] # noqa: E501
|
|
|
|
return self.api_client.call_api(
|
|
'/repos/{owner}/{repo}/issues/{index}/reactions', 'DELETE',
|
|
path_params,
|
|
query_params,
|
|
header_params,
|
|
body=body_params,
|
|
post_params=form_params,
|
|
files=local_var_files,
|
|
response_type=None, # 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 issue_delete_label(self, owner, repo, id, **kwargs): # noqa: E501
|
|
"""Delete a label # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_delete_label(owner, repo, id, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param int id: id of the label to delete (required)
|
|
:return: None
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
kwargs['_return_http_data_only'] = True
|
|
if kwargs.get('async_req'):
|
|
return self.issue_delete_label_with_http_info(owner, repo, id, **kwargs) # noqa: E501
|
|
else:
|
|
(data) = self.issue_delete_label_with_http_info(owner, repo, id, **kwargs) # noqa: E501
|
|
return data
|
|
|
|
def issue_delete_label_with_http_info(self, owner, repo, id, **kwargs): # noqa: E501
|
|
"""Delete a label # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_delete_label_with_http_info(owner, repo, id, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param int id: id of the label to delete (required)
|
|
:return: None
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
|
|
all_params = ['owner', 'repo', 'id'] # 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 issue_delete_label" % key
|
|
)
|
|
params[key] = val
|
|
del params['kwargs']
|
|
# verify the required parameter 'owner' is set
|
|
if self.api_client.client_side_validation and ('owner' not in params or
|
|
params['owner'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `owner` when calling `issue_delete_label`") # noqa: E501
|
|
# verify the required parameter 'repo' is set
|
|
if self.api_client.client_side_validation and ('repo' not in params or
|
|
params['repo'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `repo` when calling `issue_delete_label`") # noqa: E501
|
|
# verify the required parameter 'id' is set
|
|
if self.api_client.client_side_validation and ('id' not in params or
|
|
params['id'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `id` when calling `issue_delete_label`") # noqa: E501
|
|
|
|
collection_formats = {}
|
|
|
|
path_params = {}
|
|
if 'owner' in params:
|
|
path_params['owner'] = params['owner'] # noqa: E501
|
|
if 'repo' in params:
|
|
path_params['repo'] = params['repo'] # noqa: E501
|
|
if 'id' in params:
|
|
path_params['id'] = params['id'] # noqa: E501
|
|
|
|
query_params = []
|
|
|
|
header_params = {}
|
|
|
|
form_params = []
|
|
local_var_files = {}
|
|
|
|
body_params = None
|
|
# HTTP header `Accept`
|
|
header_params['Accept'] = self.api_client.select_header_accept(
|
|
['application/json', 'text/html']) # noqa: E501
|
|
|
|
# HTTP header `Content-Type`
|
|
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
|
|
['application/json', 'text/plain']) # noqa: E501
|
|
|
|
# Authentication setting
|
|
auth_settings = ['AccessToken', 'AuthorizationHeaderToken', 'BasicAuth', 'SudoHeader', 'SudoParam', 'TOTPHeader', 'Token'] # noqa: E501
|
|
|
|
return self.api_client.call_api(
|
|
'/repos/{owner}/{repo}/labels/{id}', 'DELETE',
|
|
path_params,
|
|
query_params,
|
|
header_params,
|
|
body=body_params,
|
|
post_params=form_params,
|
|
files=local_var_files,
|
|
response_type=None, # 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 issue_delete_milestone(self, owner, repo, id, **kwargs): # noqa: E501
|
|
"""Delete a milestone # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_delete_milestone(owner, repo, id, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param str id: the milestone to delete, identified by ID and if not available by name (required)
|
|
:return: None
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
kwargs['_return_http_data_only'] = True
|
|
if kwargs.get('async_req'):
|
|
return self.issue_delete_milestone_with_http_info(owner, repo, id, **kwargs) # noqa: E501
|
|
else:
|
|
(data) = self.issue_delete_milestone_with_http_info(owner, repo, id, **kwargs) # noqa: E501
|
|
return data
|
|
|
|
def issue_delete_milestone_with_http_info(self, owner, repo, id, **kwargs): # noqa: E501
|
|
"""Delete a milestone # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_delete_milestone_with_http_info(owner, repo, id, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param str id: the milestone to delete, identified by ID and if not available by name (required)
|
|
:return: None
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
|
|
all_params = ['owner', 'repo', 'id'] # 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 issue_delete_milestone" % key
|
|
)
|
|
params[key] = val
|
|
del params['kwargs']
|
|
# verify the required parameter 'owner' is set
|
|
if self.api_client.client_side_validation and ('owner' not in params or
|
|
params['owner'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `owner` when calling `issue_delete_milestone`") # noqa: E501
|
|
# verify the required parameter 'repo' is set
|
|
if self.api_client.client_side_validation and ('repo' not in params or
|
|
params['repo'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `repo` when calling `issue_delete_milestone`") # noqa: E501
|
|
# verify the required parameter 'id' is set
|
|
if self.api_client.client_side_validation and ('id' not in params or
|
|
params['id'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `id` when calling `issue_delete_milestone`") # noqa: E501
|
|
|
|
collection_formats = {}
|
|
|
|
path_params = {}
|
|
if 'owner' in params:
|
|
path_params['owner'] = params['owner'] # noqa: E501
|
|
if 'repo' in params:
|
|
path_params['repo'] = params['repo'] # noqa: E501
|
|
if 'id' in params:
|
|
path_params['id'] = params['id'] # noqa: E501
|
|
|
|
query_params = []
|
|
|
|
header_params = {}
|
|
|
|
form_params = []
|
|
local_var_files = {}
|
|
|
|
body_params = None
|
|
# HTTP header `Accept`
|
|
header_params['Accept'] = self.api_client.select_header_accept(
|
|
['application/json', 'text/html']) # noqa: E501
|
|
|
|
# HTTP header `Content-Type`
|
|
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
|
|
['application/json', 'text/plain']) # noqa: E501
|
|
|
|
# Authentication setting
|
|
auth_settings = ['AccessToken', 'AuthorizationHeaderToken', 'BasicAuth', 'SudoHeader', 'SudoParam', 'TOTPHeader', 'Token'] # noqa: E501
|
|
|
|
return self.api_client.call_api(
|
|
'/repos/{owner}/{repo}/milestones/{id}', 'DELETE',
|
|
path_params,
|
|
query_params,
|
|
header_params,
|
|
body=body_params,
|
|
post_params=form_params,
|
|
files=local_var_files,
|
|
response_type=None, # 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 issue_delete_stop_watch(self, owner, repo, index, **kwargs): # noqa: E501
|
|
"""Delete an issue's existing stopwatch. # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_delete_stop_watch(owner, repo, index, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param int index: index of the issue to stop the stopwatch on (required)
|
|
:return: None
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
kwargs['_return_http_data_only'] = True
|
|
if kwargs.get('async_req'):
|
|
return self.issue_delete_stop_watch_with_http_info(owner, repo, index, **kwargs) # noqa: E501
|
|
else:
|
|
(data) = self.issue_delete_stop_watch_with_http_info(owner, repo, index, **kwargs) # noqa: E501
|
|
return data
|
|
|
|
def issue_delete_stop_watch_with_http_info(self, owner, repo, index, **kwargs): # noqa: E501
|
|
"""Delete an issue's existing stopwatch. # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_delete_stop_watch_with_http_info(owner, repo, index, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param int index: index of the issue to stop the stopwatch on (required)
|
|
:return: None
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
|
|
all_params = ['owner', 'repo', 'index'] # 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 issue_delete_stop_watch" % key
|
|
)
|
|
params[key] = val
|
|
del params['kwargs']
|
|
# verify the required parameter 'owner' is set
|
|
if self.api_client.client_side_validation and ('owner' not in params or
|
|
params['owner'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `owner` when calling `issue_delete_stop_watch`") # noqa: E501
|
|
# verify the required parameter 'repo' is set
|
|
if self.api_client.client_side_validation and ('repo' not in params or
|
|
params['repo'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `repo` when calling `issue_delete_stop_watch`") # noqa: E501
|
|
# verify the required parameter 'index' is set
|
|
if self.api_client.client_side_validation and ('index' not in params or
|
|
params['index'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `index` when calling `issue_delete_stop_watch`") # noqa: E501
|
|
|
|
collection_formats = {}
|
|
|
|
path_params = {}
|
|
if 'owner' in params:
|
|
path_params['owner'] = params['owner'] # noqa: E501
|
|
if 'repo' in params:
|
|
path_params['repo'] = params['repo'] # noqa: E501
|
|
if 'index' in params:
|
|
path_params['index'] = params['index'] # noqa: E501
|
|
|
|
query_params = []
|
|
|
|
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
|
|
|
|
# HTTP header `Content-Type`
|
|
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
|
|
['application/json']) # noqa: E501
|
|
|
|
# Authentication setting
|
|
auth_settings = ['AccessToken', 'AuthorizationHeaderToken', 'BasicAuth', 'SudoHeader', 'SudoParam', 'TOTPHeader', 'Token'] # noqa: E501
|
|
|
|
return self.api_client.call_api(
|
|
'/repos/{owner}/{repo}/issues/{index}/stopwatch/delete', 'DELETE',
|
|
path_params,
|
|
query_params,
|
|
header_params,
|
|
body=body_params,
|
|
post_params=form_params,
|
|
files=local_var_files,
|
|
response_type=None, # 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 issue_delete_subscription(self, owner, repo, index, user, **kwargs): # noqa: E501
|
|
"""Unsubscribe user from issue # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_delete_subscription(owner, repo, index, user, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param int index: index of the issue (required)
|
|
:param str user: user witch unsubscribe (required)
|
|
:return: None
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
kwargs['_return_http_data_only'] = True
|
|
if kwargs.get('async_req'):
|
|
return self.issue_delete_subscription_with_http_info(owner, repo, index, user, **kwargs) # noqa: E501
|
|
else:
|
|
(data) = self.issue_delete_subscription_with_http_info(owner, repo, index, user, **kwargs) # noqa: E501
|
|
return data
|
|
|
|
def issue_delete_subscription_with_http_info(self, owner, repo, index, user, **kwargs): # noqa: E501
|
|
"""Unsubscribe user from issue # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_delete_subscription_with_http_info(owner, repo, index, user, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param int index: index of the issue (required)
|
|
:param str user: user witch unsubscribe (required)
|
|
:return: None
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
|
|
all_params = ['owner', 'repo', 'index', 'user'] # 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 issue_delete_subscription" % key
|
|
)
|
|
params[key] = val
|
|
del params['kwargs']
|
|
# verify the required parameter 'owner' is set
|
|
if self.api_client.client_side_validation and ('owner' not in params or
|
|
params['owner'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `owner` when calling `issue_delete_subscription`") # noqa: E501
|
|
# verify the required parameter 'repo' is set
|
|
if self.api_client.client_side_validation and ('repo' not in params or
|
|
params['repo'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `repo` when calling `issue_delete_subscription`") # noqa: E501
|
|
# verify the required parameter 'index' is set
|
|
if self.api_client.client_side_validation and ('index' not in params or
|
|
params['index'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `index` when calling `issue_delete_subscription`") # noqa: E501
|
|
# verify the required parameter 'user' is set
|
|
if self.api_client.client_side_validation and ('user' not in params or
|
|
params['user'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `user` when calling `issue_delete_subscription`") # noqa: E501
|
|
|
|
collection_formats = {}
|
|
|
|
path_params = {}
|
|
if 'owner' in params:
|
|
path_params['owner'] = params['owner'] # noqa: E501
|
|
if 'repo' in params:
|
|
path_params['repo'] = params['repo'] # noqa: E501
|
|
if 'index' in params:
|
|
path_params['index'] = params['index'] # noqa: E501
|
|
if 'user' in params:
|
|
path_params['user'] = params['user'] # noqa: E501
|
|
|
|
query_params = []
|
|
|
|
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
|
|
|
|
# HTTP header `Content-Type`
|
|
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
|
|
['application/json']) # noqa: E501
|
|
|
|
# Authentication setting
|
|
auth_settings = ['AccessToken', 'AuthorizationHeaderToken', 'BasicAuth', 'SudoHeader', 'SudoParam', 'TOTPHeader', 'Token'] # noqa: E501
|
|
|
|
return self.api_client.call_api(
|
|
'/repos/{owner}/{repo}/issues/{index}/subscriptions/{user}', 'DELETE',
|
|
path_params,
|
|
query_params,
|
|
header_params,
|
|
body=body_params,
|
|
post_params=form_params,
|
|
files=local_var_files,
|
|
response_type=None, # 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 issue_delete_time(self, owner, repo, index, id, **kwargs): # noqa: E501
|
|
"""Delete specific tracked time # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_delete_time(owner, repo, index, id, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param int index: index of the issue (required)
|
|
:param int id: id of time to delete (required)
|
|
:return: None
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
kwargs['_return_http_data_only'] = True
|
|
if kwargs.get('async_req'):
|
|
return self.issue_delete_time_with_http_info(owner, repo, index, id, **kwargs) # noqa: E501
|
|
else:
|
|
(data) = self.issue_delete_time_with_http_info(owner, repo, index, id, **kwargs) # noqa: E501
|
|
return data
|
|
|
|
def issue_delete_time_with_http_info(self, owner, repo, index, id, **kwargs): # noqa: E501
|
|
"""Delete specific tracked time # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_delete_time_with_http_info(owner, repo, index, id, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param int index: index of the issue (required)
|
|
:param int id: id of time to delete (required)
|
|
:return: None
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
|
|
all_params = ['owner', 'repo', 'index', 'id'] # 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 issue_delete_time" % key
|
|
)
|
|
params[key] = val
|
|
del params['kwargs']
|
|
# verify the required parameter 'owner' is set
|
|
if self.api_client.client_side_validation and ('owner' not in params or
|
|
params['owner'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `owner` when calling `issue_delete_time`") # noqa: E501
|
|
# verify the required parameter 'repo' is set
|
|
if self.api_client.client_side_validation and ('repo' not in params or
|
|
params['repo'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `repo` when calling `issue_delete_time`") # noqa: E501
|
|
# verify the required parameter 'index' is set
|
|
if self.api_client.client_side_validation and ('index' not in params or
|
|
params['index'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `index` when calling `issue_delete_time`") # noqa: E501
|
|
# verify the required parameter 'id' is set
|
|
if self.api_client.client_side_validation and ('id' not in params or
|
|
params['id'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `id` when calling `issue_delete_time`") # noqa: E501
|
|
|
|
collection_formats = {}
|
|
|
|
path_params = {}
|
|
if 'owner' in params:
|
|
path_params['owner'] = params['owner'] # noqa: E501
|
|
if 'repo' in params:
|
|
path_params['repo'] = params['repo'] # noqa: E501
|
|
if 'index' in params:
|
|
path_params['index'] = params['index'] # noqa: E501
|
|
if 'id' in params:
|
|
path_params['id'] = params['id'] # noqa: E501
|
|
|
|
query_params = []
|
|
|
|
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
|
|
|
|
# HTTP header `Content-Type`
|
|
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
|
|
['application/json']) # noqa: E501
|
|
|
|
# Authentication setting
|
|
auth_settings = ['AccessToken', 'AuthorizationHeaderToken', 'BasicAuth', 'SudoHeader', 'SudoParam', 'TOTPHeader', 'Token'] # noqa: E501
|
|
|
|
return self.api_client.call_api(
|
|
'/repos/{owner}/{repo}/issues/{index}/times/{id}', 'DELETE',
|
|
path_params,
|
|
query_params,
|
|
header_params,
|
|
body=body_params,
|
|
post_params=form_params,
|
|
files=local_var_files,
|
|
response_type=None, # 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 issue_edit_comment(self, owner, repo, id, **kwargs): # noqa: E501
|
|
"""Edit a comment # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_edit_comment(owner, repo, id, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param int id: id of the comment to edit (required)
|
|
:param EditIssueCommentOption body:
|
|
:return: Comment
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
kwargs['_return_http_data_only'] = True
|
|
if kwargs.get('async_req'):
|
|
return self.issue_edit_comment_with_http_info(owner, repo, id, **kwargs) # noqa: E501
|
|
else:
|
|
(data) = self.issue_edit_comment_with_http_info(owner, repo, id, **kwargs) # noqa: E501
|
|
return data
|
|
|
|
def issue_edit_comment_with_http_info(self, owner, repo, id, **kwargs): # noqa: E501
|
|
"""Edit a comment # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_edit_comment_with_http_info(owner, repo, id, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param int id: id of the comment to edit (required)
|
|
:param EditIssueCommentOption body:
|
|
:return: Comment
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
|
|
all_params = ['owner', 'repo', 'id', 'body'] # 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 issue_edit_comment" % key
|
|
)
|
|
params[key] = val
|
|
del params['kwargs']
|
|
# verify the required parameter 'owner' is set
|
|
if self.api_client.client_side_validation and ('owner' not in params or
|
|
params['owner'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `owner` when calling `issue_edit_comment`") # noqa: E501
|
|
# verify the required parameter 'repo' is set
|
|
if self.api_client.client_side_validation and ('repo' not in params or
|
|
params['repo'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `repo` when calling `issue_edit_comment`") # noqa: E501
|
|
# verify the required parameter 'id' is set
|
|
if self.api_client.client_side_validation and ('id' not in params or
|
|
params['id'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `id` when calling `issue_edit_comment`") # noqa: E501
|
|
|
|
collection_formats = {}
|
|
|
|
path_params = {}
|
|
if 'owner' in params:
|
|
path_params['owner'] = params['owner'] # noqa: E501
|
|
if 'repo' in params:
|
|
path_params['repo'] = params['repo'] # noqa: E501
|
|
if 'id' in params:
|
|
path_params['id'] = params['id'] # noqa: E501
|
|
|
|
query_params = []
|
|
|
|
header_params = {}
|
|
|
|
form_params = []
|
|
local_var_files = {}
|
|
|
|
body_params = None
|
|
if 'body' in params:
|
|
body_params = params['body']
|
|
# HTTP header `Accept`
|
|
header_params['Accept'] = self.api_client.select_header_accept(
|
|
['application/json']) # noqa: E501
|
|
|
|
# HTTP header `Content-Type`
|
|
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
|
|
['application/json']) # noqa: E501
|
|
|
|
# Authentication setting
|
|
auth_settings = ['AccessToken', 'AuthorizationHeaderToken', 'BasicAuth', 'SudoHeader', 'SudoParam', 'TOTPHeader', 'Token'] # noqa: E501
|
|
|
|
return self.api_client.call_api(
|
|
'/repos/{owner}/{repo}/issues/comments/{id}', 'PATCH',
|
|
path_params,
|
|
query_params,
|
|
header_params,
|
|
body=body_params,
|
|
post_params=form_params,
|
|
files=local_var_files,
|
|
response_type='Comment', # 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 issue_edit_comment_deprecated(self, owner, repo, index, id, **kwargs): # noqa: E501
|
|
"""Edit a comment # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_edit_comment_deprecated(owner, repo, index, id, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param int index: this parameter is ignored (required)
|
|
:param int id: id of the comment to edit (required)
|
|
:param EditIssueCommentOption body:
|
|
:return: Comment
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
kwargs['_return_http_data_only'] = True
|
|
if kwargs.get('async_req'):
|
|
return self.issue_edit_comment_deprecated_with_http_info(owner, repo, index, id, **kwargs) # noqa: E501
|
|
else:
|
|
(data) = self.issue_edit_comment_deprecated_with_http_info(owner, repo, index, id, **kwargs) # noqa: E501
|
|
return data
|
|
|
|
def issue_edit_comment_deprecated_with_http_info(self, owner, repo, index, id, **kwargs): # noqa: E501
|
|
"""Edit a comment # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_edit_comment_deprecated_with_http_info(owner, repo, index, id, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param int index: this parameter is ignored (required)
|
|
:param int id: id of the comment to edit (required)
|
|
:param EditIssueCommentOption body:
|
|
:return: Comment
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
|
|
all_params = ['owner', 'repo', 'index', 'id', 'body'] # 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 issue_edit_comment_deprecated" % key
|
|
)
|
|
params[key] = val
|
|
del params['kwargs']
|
|
# verify the required parameter 'owner' is set
|
|
if self.api_client.client_side_validation and ('owner' not in params or
|
|
params['owner'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `owner` when calling `issue_edit_comment_deprecated`") # noqa: E501
|
|
# verify the required parameter 'repo' is set
|
|
if self.api_client.client_side_validation and ('repo' not in params or
|
|
params['repo'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `repo` when calling `issue_edit_comment_deprecated`") # noqa: E501
|
|
# verify the required parameter 'index' is set
|
|
if self.api_client.client_side_validation and ('index' not in params or
|
|
params['index'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `index` when calling `issue_edit_comment_deprecated`") # noqa: E501
|
|
# verify the required parameter 'id' is set
|
|
if self.api_client.client_side_validation and ('id' not in params or
|
|
params['id'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `id` when calling `issue_edit_comment_deprecated`") # noqa: E501
|
|
|
|
collection_formats = {}
|
|
|
|
path_params = {}
|
|
if 'owner' in params:
|
|
path_params['owner'] = params['owner'] # noqa: E501
|
|
if 'repo' in params:
|
|
path_params['repo'] = params['repo'] # noqa: E501
|
|
if 'index' in params:
|
|
path_params['index'] = params['index'] # noqa: E501
|
|
if 'id' in params:
|
|
path_params['id'] = params['id'] # noqa: E501
|
|
|
|
query_params = []
|
|
|
|
header_params = {}
|
|
|
|
form_params = []
|
|
local_var_files = {}
|
|
|
|
body_params = None
|
|
if 'body' in params:
|
|
body_params = params['body']
|
|
# HTTP header `Accept`
|
|
header_params['Accept'] = self.api_client.select_header_accept(
|
|
['application/json']) # noqa: E501
|
|
|
|
# HTTP header `Content-Type`
|
|
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
|
|
['application/json']) # noqa: E501
|
|
|
|
# Authentication setting
|
|
auth_settings = ['AccessToken', 'AuthorizationHeaderToken', 'BasicAuth', 'SudoHeader', 'SudoParam', 'TOTPHeader', 'Token'] # noqa: E501
|
|
|
|
return self.api_client.call_api(
|
|
'/repos/{owner}/{repo}/issues/{index}/comments/{id}', 'PATCH',
|
|
path_params,
|
|
query_params,
|
|
header_params,
|
|
body=body_params,
|
|
post_params=form_params,
|
|
files=local_var_files,
|
|
response_type='Comment', # 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 issue_edit_issue(self, owner, repo, index, **kwargs): # noqa: E501
|
|
"""Edit an issue. If using deadline only the date will be taken into account, and time of day ignored. # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_edit_issue(owner, repo, index, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param int index: index of the issue to edit (required)
|
|
:param EditIssueOption body:
|
|
:return: Issue
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
kwargs['_return_http_data_only'] = True
|
|
if kwargs.get('async_req'):
|
|
return self.issue_edit_issue_with_http_info(owner, repo, index, **kwargs) # noqa: E501
|
|
else:
|
|
(data) = self.issue_edit_issue_with_http_info(owner, repo, index, **kwargs) # noqa: E501
|
|
return data
|
|
|
|
def issue_edit_issue_with_http_info(self, owner, repo, index, **kwargs): # noqa: E501
|
|
"""Edit an issue. If using deadline only the date will be taken into account, and time of day ignored. # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_edit_issue_with_http_info(owner, repo, index, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param int index: index of the issue to edit (required)
|
|
:param EditIssueOption body:
|
|
:return: Issue
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
|
|
all_params = ['owner', 'repo', 'index', 'body'] # 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 issue_edit_issue" % key
|
|
)
|
|
params[key] = val
|
|
del params['kwargs']
|
|
# verify the required parameter 'owner' is set
|
|
if self.api_client.client_side_validation and ('owner' not in params or
|
|
params['owner'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `owner` when calling `issue_edit_issue`") # noqa: E501
|
|
# verify the required parameter 'repo' is set
|
|
if self.api_client.client_side_validation and ('repo' not in params or
|
|
params['repo'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `repo` when calling `issue_edit_issue`") # noqa: E501
|
|
# verify the required parameter 'index' is set
|
|
if self.api_client.client_side_validation and ('index' not in params or
|
|
params['index'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `index` when calling `issue_edit_issue`") # noqa: E501
|
|
|
|
collection_formats = {}
|
|
|
|
path_params = {}
|
|
if 'owner' in params:
|
|
path_params['owner'] = params['owner'] # noqa: E501
|
|
if 'repo' in params:
|
|
path_params['repo'] = params['repo'] # noqa: E501
|
|
if 'index' in params:
|
|
path_params['index'] = params['index'] # noqa: E501
|
|
|
|
query_params = []
|
|
|
|
header_params = {}
|
|
|
|
form_params = []
|
|
local_var_files = {}
|
|
|
|
body_params = None
|
|
if 'body' in params:
|
|
body_params = params['body']
|
|
# HTTP header `Accept`
|
|
header_params['Accept'] = self.api_client.select_header_accept(
|
|
['application/json']) # noqa: E501
|
|
|
|
# HTTP header `Content-Type`
|
|
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
|
|
['application/json']) # noqa: E501
|
|
|
|
# Authentication setting
|
|
auth_settings = ['AccessToken', 'AuthorizationHeaderToken', 'BasicAuth', 'SudoHeader', 'SudoParam', 'TOTPHeader', 'Token'] # noqa: E501
|
|
|
|
return self.api_client.call_api(
|
|
'/repos/{owner}/{repo}/issues/{index}', 'PATCH',
|
|
path_params,
|
|
query_params,
|
|
header_params,
|
|
body=body_params,
|
|
post_params=form_params,
|
|
files=local_var_files,
|
|
response_type='Issue', # 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 issue_edit_issue_deadline(self, owner, repo, index, **kwargs): # noqa: E501
|
|
"""Set an issue deadline. If set to null, the deadline is deleted. If using deadline only the date will be taken into account, and time of day ignored. # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_edit_issue_deadline(owner, repo, index, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param int index: index of the issue to create or update a deadline on (required)
|
|
:param EditDeadlineOption body:
|
|
:return: IssueDeadline
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
kwargs['_return_http_data_only'] = True
|
|
if kwargs.get('async_req'):
|
|
return self.issue_edit_issue_deadline_with_http_info(owner, repo, index, **kwargs) # noqa: E501
|
|
else:
|
|
(data) = self.issue_edit_issue_deadline_with_http_info(owner, repo, index, **kwargs) # noqa: E501
|
|
return data
|
|
|
|
def issue_edit_issue_deadline_with_http_info(self, owner, repo, index, **kwargs): # noqa: E501
|
|
"""Set an issue deadline. If set to null, the deadline is deleted. If using deadline only the date will be taken into account, and time of day ignored. # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_edit_issue_deadline_with_http_info(owner, repo, index, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param int index: index of the issue to create or update a deadline on (required)
|
|
:param EditDeadlineOption body:
|
|
:return: IssueDeadline
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
|
|
all_params = ['owner', 'repo', 'index', 'body'] # 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 issue_edit_issue_deadline" % key
|
|
)
|
|
params[key] = val
|
|
del params['kwargs']
|
|
# verify the required parameter 'owner' is set
|
|
if self.api_client.client_side_validation and ('owner' not in params or
|
|
params['owner'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `owner` when calling `issue_edit_issue_deadline`") # noqa: E501
|
|
# verify the required parameter 'repo' is set
|
|
if self.api_client.client_side_validation and ('repo' not in params or
|
|
params['repo'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `repo` when calling `issue_edit_issue_deadline`") # noqa: E501
|
|
# verify the required parameter 'index' is set
|
|
if self.api_client.client_side_validation and ('index' not in params or
|
|
params['index'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `index` when calling `issue_edit_issue_deadline`") # noqa: E501
|
|
|
|
collection_formats = {}
|
|
|
|
path_params = {}
|
|
if 'owner' in params:
|
|
path_params['owner'] = params['owner'] # noqa: E501
|
|
if 'repo' in params:
|
|
path_params['repo'] = params['repo'] # noqa: E501
|
|
if 'index' in params:
|
|
path_params['index'] = params['index'] # noqa: E501
|
|
|
|
query_params = []
|
|
|
|
header_params = {}
|
|
|
|
form_params = []
|
|
local_var_files = {}
|
|
|
|
body_params = None
|
|
if 'body' in params:
|
|
body_params = params['body']
|
|
# HTTP header `Accept`
|
|
header_params['Accept'] = self.api_client.select_header_accept(
|
|
['application/json']) # noqa: E501
|
|
|
|
# HTTP header `Content-Type`
|
|
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
|
|
['application/json']) # noqa: E501
|
|
|
|
# Authentication setting
|
|
auth_settings = ['AccessToken', 'AuthorizationHeaderToken', 'BasicAuth', 'SudoHeader', 'SudoParam', 'TOTPHeader', 'Token'] # noqa: E501
|
|
|
|
return self.api_client.call_api(
|
|
'/repos/{owner}/{repo}/issues/{index}/deadline', 'POST',
|
|
path_params,
|
|
query_params,
|
|
header_params,
|
|
body=body_params,
|
|
post_params=form_params,
|
|
files=local_var_files,
|
|
response_type='IssueDeadline', # 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 issue_edit_label(self, owner, repo, id, **kwargs): # noqa: E501
|
|
"""Update a label # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_edit_label(owner, repo, id, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param int id: id of the label to edit (required)
|
|
:param EditLabelOption body:
|
|
:return: Label
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
kwargs['_return_http_data_only'] = True
|
|
if kwargs.get('async_req'):
|
|
return self.issue_edit_label_with_http_info(owner, repo, id, **kwargs) # noqa: E501
|
|
else:
|
|
(data) = self.issue_edit_label_with_http_info(owner, repo, id, **kwargs) # noqa: E501
|
|
return data
|
|
|
|
def issue_edit_label_with_http_info(self, owner, repo, id, **kwargs): # noqa: E501
|
|
"""Update a label # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_edit_label_with_http_info(owner, repo, id, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param int id: id of the label to edit (required)
|
|
:param EditLabelOption body:
|
|
:return: Label
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
|
|
all_params = ['owner', 'repo', 'id', 'body'] # 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 issue_edit_label" % key
|
|
)
|
|
params[key] = val
|
|
del params['kwargs']
|
|
# verify the required parameter 'owner' is set
|
|
if self.api_client.client_side_validation and ('owner' not in params or
|
|
params['owner'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `owner` when calling `issue_edit_label`") # noqa: E501
|
|
# verify the required parameter 'repo' is set
|
|
if self.api_client.client_side_validation and ('repo' not in params or
|
|
params['repo'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `repo` when calling `issue_edit_label`") # noqa: E501
|
|
# verify the required parameter 'id' is set
|
|
if self.api_client.client_side_validation and ('id' not in params or
|
|
params['id'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `id` when calling `issue_edit_label`") # noqa: E501
|
|
|
|
collection_formats = {}
|
|
|
|
path_params = {}
|
|
if 'owner' in params:
|
|
path_params['owner'] = params['owner'] # noqa: E501
|
|
if 'repo' in params:
|
|
path_params['repo'] = params['repo'] # noqa: E501
|
|
if 'id' in params:
|
|
path_params['id'] = params['id'] # noqa: E501
|
|
|
|
query_params = []
|
|
|
|
header_params = {}
|
|
|
|
form_params = []
|
|
local_var_files = {}
|
|
|
|
body_params = None
|
|
if 'body' in params:
|
|
body_params = params['body']
|
|
# HTTP header `Accept`
|
|
header_params['Accept'] = self.api_client.select_header_accept(
|
|
['application/json']) # noqa: E501
|
|
|
|
# HTTP header `Content-Type`
|
|
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
|
|
['application/json']) # noqa: E501
|
|
|
|
# Authentication setting
|
|
auth_settings = ['AccessToken', 'AuthorizationHeaderToken', 'BasicAuth', 'SudoHeader', 'SudoParam', 'TOTPHeader', 'Token'] # noqa: E501
|
|
|
|
return self.api_client.call_api(
|
|
'/repos/{owner}/{repo}/labels/{id}', 'PATCH',
|
|
path_params,
|
|
query_params,
|
|
header_params,
|
|
body=body_params,
|
|
post_params=form_params,
|
|
files=local_var_files,
|
|
response_type='Label', # 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 issue_edit_milestone(self, owner, repo, id, **kwargs): # noqa: E501
|
|
"""Update a milestone # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_edit_milestone(owner, repo, id, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param str id: the milestone to edit, identified by ID and if not available by name (required)
|
|
:param EditMilestoneOption body:
|
|
:return: Milestone
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
kwargs['_return_http_data_only'] = True
|
|
if kwargs.get('async_req'):
|
|
return self.issue_edit_milestone_with_http_info(owner, repo, id, **kwargs) # noqa: E501
|
|
else:
|
|
(data) = self.issue_edit_milestone_with_http_info(owner, repo, id, **kwargs) # noqa: E501
|
|
return data
|
|
|
|
def issue_edit_milestone_with_http_info(self, owner, repo, id, **kwargs): # noqa: E501
|
|
"""Update a milestone # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_edit_milestone_with_http_info(owner, repo, id, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param str id: the milestone to edit, identified by ID and if not available by name (required)
|
|
:param EditMilestoneOption body:
|
|
:return: Milestone
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
|
|
all_params = ['owner', 'repo', 'id', 'body'] # 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 issue_edit_milestone" % key
|
|
)
|
|
params[key] = val
|
|
del params['kwargs']
|
|
# verify the required parameter 'owner' is set
|
|
if self.api_client.client_side_validation and ('owner' not in params or
|
|
params['owner'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `owner` when calling `issue_edit_milestone`") # noqa: E501
|
|
# verify the required parameter 'repo' is set
|
|
if self.api_client.client_side_validation and ('repo' not in params or
|
|
params['repo'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `repo` when calling `issue_edit_milestone`") # noqa: E501
|
|
# verify the required parameter 'id' is set
|
|
if self.api_client.client_side_validation and ('id' not in params or
|
|
params['id'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `id` when calling `issue_edit_milestone`") # noqa: E501
|
|
|
|
collection_formats = {}
|
|
|
|
path_params = {}
|
|
if 'owner' in params:
|
|
path_params['owner'] = params['owner'] # noqa: E501
|
|
if 'repo' in params:
|
|
path_params['repo'] = params['repo'] # noqa: E501
|
|
if 'id' in params:
|
|
path_params['id'] = params['id'] # noqa: E501
|
|
|
|
query_params = []
|
|
|
|
header_params = {}
|
|
|
|
form_params = []
|
|
local_var_files = {}
|
|
|
|
body_params = None
|
|
if 'body' in params:
|
|
body_params = params['body']
|
|
# HTTP header `Accept`
|
|
header_params['Accept'] = self.api_client.select_header_accept(
|
|
['application/json']) # noqa: E501
|
|
|
|
# HTTP header `Content-Type`
|
|
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
|
|
['application/json']) # noqa: E501
|
|
|
|
# Authentication setting
|
|
auth_settings = ['AccessToken', 'AuthorizationHeaderToken', 'BasicAuth', 'SudoHeader', 'SudoParam', 'TOTPHeader', 'Token'] # noqa: E501
|
|
|
|
return self.api_client.call_api(
|
|
'/repos/{owner}/{repo}/milestones/{id}', 'PATCH',
|
|
path_params,
|
|
query_params,
|
|
header_params,
|
|
body=body_params,
|
|
post_params=form_params,
|
|
files=local_var_files,
|
|
response_type='Milestone', # 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 issue_get_comment(self, owner, repo, id, **kwargs): # noqa: E501
|
|
"""Get a comment # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_get_comment(owner, repo, id, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param int id: id of the comment (required)
|
|
:return: Comment
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
kwargs['_return_http_data_only'] = True
|
|
if kwargs.get('async_req'):
|
|
return self.issue_get_comment_with_http_info(owner, repo, id, **kwargs) # noqa: E501
|
|
else:
|
|
(data) = self.issue_get_comment_with_http_info(owner, repo, id, **kwargs) # noqa: E501
|
|
return data
|
|
|
|
def issue_get_comment_with_http_info(self, owner, repo, id, **kwargs): # noqa: E501
|
|
"""Get a comment # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_get_comment_with_http_info(owner, repo, id, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param int id: id of the comment (required)
|
|
:return: Comment
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
|
|
all_params = ['owner', 'repo', 'id'] # 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 issue_get_comment" % key
|
|
)
|
|
params[key] = val
|
|
del params['kwargs']
|
|
# verify the required parameter 'owner' is set
|
|
if self.api_client.client_side_validation and ('owner' not in params or
|
|
params['owner'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `owner` when calling `issue_get_comment`") # noqa: E501
|
|
# verify the required parameter 'repo' is set
|
|
if self.api_client.client_side_validation and ('repo' not in params or
|
|
params['repo'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `repo` when calling `issue_get_comment`") # noqa: E501
|
|
# verify the required parameter 'id' is set
|
|
if self.api_client.client_side_validation and ('id' not in params or
|
|
params['id'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `id` when calling `issue_get_comment`") # noqa: E501
|
|
|
|
collection_formats = {}
|
|
|
|
path_params = {}
|
|
if 'owner' in params:
|
|
path_params['owner'] = params['owner'] # noqa: E501
|
|
if 'repo' in params:
|
|
path_params['repo'] = params['repo'] # noqa: E501
|
|
if 'id' in params:
|
|
path_params['id'] = params['id'] # noqa: E501
|
|
|
|
query_params = []
|
|
|
|
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
|
|
|
|
# HTTP header `Content-Type`
|
|
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
|
|
['application/json']) # noqa: E501
|
|
|
|
# Authentication setting
|
|
auth_settings = ['AccessToken', 'AuthorizationHeaderToken', 'BasicAuth', 'SudoHeader', 'SudoParam', 'TOTPHeader', 'Token'] # noqa: E501
|
|
|
|
return self.api_client.call_api(
|
|
'/repos/{owner}/{repo}/issues/comments/{id}', 'GET',
|
|
path_params,
|
|
query_params,
|
|
header_params,
|
|
body=body_params,
|
|
post_params=form_params,
|
|
files=local_var_files,
|
|
response_type='Comment', # 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 issue_get_comment_reactions(self, owner, repo, id, **kwargs): # noqa: E501
|
|
"""Get a list of reactions from a comment of an issue # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_get_comment_reactions(owner, repo, id, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param int id: id of the comment to edit (required)
|
|
:return: list[Reaction]
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
kwargs['_return_http_data_only'] = True
|
|
if kwargs.get('async_req'):
|
|
return self.issue_get_comment_reactions_with_http_info(owner, repo, id, **kwargs) # noqa: E501
|
|
else:
|
|
(data) = self.issue_get_comment_reactions_with_http_info(owner, repo, id, **kwargs) # noqa: E501
|
|
return data
|
|
|
|
def issue_get_comment_reactions_with_http_info(self, owner, repo, id, **kwargs): # noqa: E501
|
|
"""Get a list of reactions from a comment of an issue # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_get_comment_reactions_with_http_info(owner, repo, id, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param int id: id of the comment to edit (required)
|
|
:return: list[Reaction]
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
|
|
all_params = ['owner', 'repo', 'id'] # 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 issue_get_comment_reactions" % key
|
|
)
|
|
params[key] = val
|
|
del params['kwargs']
|
|
# verify the required parameter 'owner' is set
|
|
if self.api_client.client_side_validation and ('owner' not in params or
|
|
params['owner'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `owner` when calling `issue_get_comment_reactions`") # noqa: E501
|
|
# verify the required parameter 'repo' is set
|
|
if self.api_client.client_side_validation and ('repo' not in params or
|
|
params['repo'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `repo` when calling `issue_get_comment_reactions`") # noqa: E501
|
|
# verify the required parameter 'id' is set
|
|
if self.api_client.client_side_validation and ('id' not in params or
|
|
params['id'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `id` when calling `issue_get_comment_reactions`") # noqa: E501
|
|
|
|
collection_formats = {}
|
|
|
|
path_params = {}
|
|
if 'owner' in params:
|
|
path_params['owner'] = params['owner'] # noqa: E501
|
|
if 'repo' in params:
|
|
path_params['repo'] = params['repo'] # noqa: E501
|
|
if 'id' in params:
|
|
path_params['id'] = params['id'] # noqa: E501
|
|
|
|
query_params = []
|
|
|
|
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
|
|
|
|
# HTTP header `Content-Type`
|
|
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
|
|
['application/json']) # noqa: E501
|
|
|
|
# Authentication setting
|
|
auth_settings = ['AccessToken', 'AuthorizationHeaderToken', 'BasicAuth', 'SudoHeader', 'SudoParam', 'TOTPHeader', 'Token'] # noqa: E501
|
|
|
|
return self.api_client.call_api(
|
|
'/repos/{owner}/{repo}/issues/comments/{id}/reactions', 'GET',
|
|
path_params,
|
|
query_params,
|
|
header_params,
|
|
body=body_params,
|
|
post_params=form_params,
|
|
files=local_var_files,
|
|
response_type='list[Reaction]', # 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 issue_get_comments(self, owner, repo, index, **kwargs): # noqa: E501
|
|
"""List all comments on an issue # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_get_comments(owner, repo, index, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param int index: index of the issue (required)
|
|
:param datetime since: if provided, only comments updated since the specified time are returned.
|
|
:param datetime before: if provided, only comments updated before the provided time are returned.
|
|
:return: list[Comment]
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
kwargs['_return_http_data_only'] = True
|
|
if kwargs.get('async_req'):
|
|
return self.issue_get_comments_with_http_info(owner, repo, index, **kwargs) # noqa: E501
|
|
else:
|
|
(data) = self.issue_get_comments_with_http_info(owner, repo, index, **kwargs) # noqa: E501
|
|
return data
|
|
|
|
def issue_get_comments_with_http_info(self, owner, repo, index, **kwargs): # noqa: E501
|
|
"""List all comments on an issue # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_get_comments_with_http_info(owner, repo, index, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param int index: index of the issue (required)
|
|
:param datetime since: if provided, only comments updated since the specified time are returned.
|
|
:param datetime before: if provided, only comments updated before the provided time are returned.
|
|
:return: list[Comment]
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
|
|
all_params = ['owner', 'repo', 'index', 'since', 'before'] # 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 issue_get_comments" % key
|
|
)
|
|
params[key] = val
|
|
del params['kwargs']
|
|
# verify the required parameter 'owner' is set
|
|
if self.api_client.client_side_validation and ('owner' not in params or
|
|
params['owner'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `owner` when calling `issue_get_comments`") # noqa: E501
|
|
# verify the required parameter 'repo' is set
|
|
if self.api_client.client_side_validation and ('repo' not in params or
|
|
params['repo'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `repo` when calling `issue_get_comments`") # noqa: E501
|
|
# verify the required parameter 'index' is set
|
|
if self.api_client.client_side_validation and ('index' not in params or
|
|
params['index'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `index` when calling `issue_get_comments`") # noqa: E501
|
|
|
|
collection_formats = {}
|
|
|
|
path_params = {}
|
|
if 'owner' in params:
|
|
path_params['owner'] = params['owner'] # noqa: E501
|
|
if 'repo' in params:
|
|
path_params['repo'] = params['repo'] # noqa: E501
|
|
if 'index' in params:
|
|
path_params['index'] = params['index'] # noqa: E501
|
|
|
|
query_params = []
|
|
if 'since' in params:
|
|
query_params.append(('since', params['since'])) # noqa: E501
|
|
if 'before' in params:
|
|
query_params.append(('before', params['before'])) # 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
|
|
|
|
# HTTP header `Content-Type`
|
|
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
|
|
['application/json', 'text/plain']) # noqa: E501
|
|
|
|
# Authentication setting
|
|
auth_settings = ['AccessToken', 'AuthorizationHeaderToken', 'BasicAuth', 'SudoHeader', 'SudoParam', 'TOTPHeader', 'Token'] # noqa: E501
|
|
|
|
return self.api_client.call_api(
|
|
'/repos/{owner}/{repo}/issues/{index}/comments', 'GET',
|
|
path_params,
|
|
query_params,
|
|
header_params,
|
|
body=body_params,
|
|
post_params=form_params,
|
|
files=local_var_files,
|
|
response_type='list[Comment]', # 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 issue_get_comments_and_timeline(self, owner, repo, index, **kwargs): # noqa: E501
|
|
"""List all comments and events on an issue # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_get_comments_and_timeline(owner, repo, index, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param int index: index of the issue (required)
|
|
:param datetime since: if provided, only comments updated since the specified time are returned.
|
|
:param int page: page number of results to return (1-based)
|
|
:param int limit: page size of results
|
|
:param datetime before: if provided, only comments updated before the provided time are returned.
|
|
:return: list[TimelineComment]
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
kwargs['_return_http_data_only'] = True
|
|
if kwargs.get('async_req'):
|
|
return self.issue_get_comments_and_timeline_with_http_info(owner, repo, index, **kwargs) # noqa: E501
|
|
else:
|
|
(data) = self.issue_get_comments_and_timeline_with_http_info(owner, repo, index, **kwargs) # noqa: E501
|
|
return data
|
|
|
|
def issue_get_comments_and_timeline_with_http_info(self, owner, repo, index, **kwargs): # noqa: E501
|
|
"""List all comments and events on an issue # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_get_comments_and_timeline_with_http_info(owner, repo, index, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param int index: index of the issue (required)
|
|
:param datetime since: if provided, only comments updated since the specified time are returned.
|
|
:param int page: page number of results to return (1-based)
|
|
:param int limit: page size of results
|
|
:param datetime before: if provided, only comments updated before the provided time are returned.
|
|
:return: list[TimelineComment]
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
|
|
all_params = ['owner', 'repo', 'index', 'since', 'page', 'limit', 'before'] # 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 issue_get_comments_and_timeline" % key
|
|
)
|
|
params[key] = val
|
|
del params['kwargs']
|
|
# verify the required parameter 'owner' is set
|
|
if self.api_client.client_side_validation and ('owner' not in params or
|
|
params['owner'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `owner` when calling `issue_get_comments_and_timeline`") # noqa: E501
|
|
# verify the required parameter 'repo' is set
|
|
if self.api_client.client_side_validation and ('repo' not in params or
|
|
params['repo'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `repo` when calling `issue_get_comments_and_timeline`") # noqa: E501
|
|
# verify the required parameter 'index' is set
|
|
if self.api_client.client_side_validation and ('index' not in params or
|
|
params['index'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `index` when calling `issue_get_comments_and_timeline`") # noqa: E501
|
|
|
|
collection_formats = {}
|
|
|
|
path_params = {}
|
|
if 'owner' in params:
|
|
path_params['owner'] = params['owner'] # noqa: E501
|
|
if 'repo' in params:
|
|
path_params['repo'] = params['repo'] # noqa: E501
|
|
if 'index' in params:
|
|
path_params['index'] = params['index'] # noqa: E501
|
|
|
|
query_params = []
|
|
if 'since' in params:
|
|
query_params.append(('since', params['since'])) # noqa: E501
|
|
if 'page' in params:
|
|
query_params.append(('page', params['page'])) # noqa: E501
|
|
if 'limit' in params:
|
|
query_params.append(('limit', params['limit'])) # noqa: E501
|
|
if 'before' in params:
|
|
query_params.append(('before', params['before'])) # 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
|
|
|
|
# HTTP header `Content-Type`
|
|
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
|
|
['application/json', 'text/plain']) # noqa: E501
|
|
|
|
# Authentication setting
|
|
auth_settings = ['AccessToken', 'AuthorizationHeaderToken', 'BasicAuth', 'SudoHeader', 'SudoParam', 'TOTPHeader', 'Token'] # noqa: E501
|
|
|
|
return self.api_client.call_api(
|
|
'/repos/{owner}/{repo}/issues/{index}/timeline', 'GET',
|
|
path_params,
|
|
query_params,
|
|
header_params,
|
|
body=body_params,
|
|
post_params=form_params,
|
|
files=local_var_files,
|
|
response_type='list[TimelineComment]', # 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 issue_get_issue(self, owner, repo, index, **kwargs): # noqa: E501
|
|
"""Get an issue # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_get_issue(owner, repo, index, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param int index: index of the issue to get (required)
|
|
:return: Issue
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
kwargs['_return_http_data_only'] = True
|
|
if kwargs.get('async_req'):
|
|
return self.issue_get_issue_with_http_info(owner, repo, index, **kwargs) # noqa: E501
|
|
else:
|
|
(data) = self.issue_get_issue_with_http_info(owner, repo, index, **kwargs) # noqa: E501
|
|
return data
|
|
|
|
def issue_get_issue_with_http_info(self, owner, repo, index, **kwargs): # noqa: E501
|
|
"""Get an issue # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_get_issue_with_http_info(owner, repo, index, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param int index: index of the issue to get (required)
|
|
:return: Issue
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
|
|
all_params = ['owner', 'repo', 'index'] # 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 issue_get_issue" % key
|
|
)
|
|
params[key] = val
|
|
del params['kwargs']
|
|
# verify the required parameter 'owner' is set
|
|
if self.api_client.client_side_validation and ('owner' not in params or
|
|
params['owner'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `owner` when calling `issue_get_issue`") # noqa: E501
|
|
# verify the required parameter 'repo' is set
|
|
if self.api_client.client_side_validation and ('repo' not in params or
|
|
params['repo'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `repo` when calling `issue_get_issue`") # noqa: E501
|
|
# verify the required parameter 'index' is set
|
|
if self.api_client.client_side_validation and ('index' not in params or
|
|
params['index'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `index` when calling `issue_get_issue`") # noqa: E501
|
|
|
|
collection_formats = {}
|
|
|
|
path_params = {}
|
|
if 'owner' in params:
|
|
path_params['owner'] = params['owner'] # noqa: E501
|
|
if 'repo' in params:
|
|
path_params['repo'] = params['repo'] # noqa: E501
|
|
if 'index' in params:
|
|
path_params['index'] = params['index'] # noqa: E501
|
|
|
|
query_params = []
|
|
|
|
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
|
|
|
|
# HTTP header `Content-Type`
|
|
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
|
|
['application/json', 'text/plain']) # noqa: E501
|
|
|
|
# Authentication setting
|
|
auth_settings = ['AccessToken', 'AuthorizationHeaderToken', 'BasicAuth', 'SudoHeader', 'SudoParam', 'TOTPHeader', 'Token'] # noqa: E501
|
|
|
|
return self.api_client.call_api(
|
|
'/repos/{owner}/{repo}/issues/{index}', 'GET',
|
|
path_params,
|
|
query_params,
|
|
header_params,
|
|
body=body_params,
|
|
post_params=form_params,
|
|
files=local_var_files,
|
|
response_type='Issue', # 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 issue_get_issue_reactions(self, owner, repo, index, **kwargs): # noqa: E501
|
|
"""Get a list reactions of an issue # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_get_issue_reactions(owner, repo, index, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param int index: index of the issue (required)
|
|
:param int page: page number of results to return (1-based)
|
|
:param int limit: page size of results
|
|
:return: list[Reaction]
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
kwargs['_return_http_data_only'] = True
|
|
if kwargs.get('async_req'):
|
|
return self.issue_get_issue_reactions_with_http_info(owner, repo, index, **kwargs) # noqa: E501
|
|
else:
|
|
(data) = self.issue_get_issue_reactions_with_http_info(owner, repo, index, **kwargs) # noqa: E501
|
|
return data
|
|
|
|
def issue_get_issue_reactions_with_http_info(self, owner, repo, index, **kwargs): # noqa: E501
|
|
"""Get a list reactions of an issue # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_get_issue_reactions_with_http_info(owner, repo, index, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param int index: index of the issue (required)
|
|
:param int page: page number of results to return (1-based)
|
|
:param int limit: page size of results
|
|
:return: list[Reaction]
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
|
|
all_params = ['owner', 'repo', 'index', 'page', 'limit'] # 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 issue_get_issue_reactions" % key
|
|
)
|
|
params[key] = val
|
|
del params['kwargs']
|
|
# verify the required parameter 'owner' is set
|
|
if self.api_client.client_side_validation and ('owner' not in params or
|
|
params['owner'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `owner` when calling `issue_get_issue_reactions`") # noqa: E501
|
|
# verify the required parameter 'repo' is set
|
|
if self.api_client.client_side_validation and ('repo' not in params or
|
|
params['repo'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `repo` when calling `issue_get_issue_reactions`") # noqa: E501
|
|
# verify the required parameter 'index' is set
|
|
if self.api_client.client_side_validation and ('index' not in params or
|
|
params['index'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `index` when calling `issue_get_issue_reactions`") # noqa: E501
|
|
|
|
collection_formats = {}
|
|
|
|
path_params = {}
|
|
if 'owner' in params:
|
|
path_params['owner'] = params['owner'] # noqa: E501
|
|
if 'repo' in params:
|
|
path_params['repo'] = params['repo'] # noqa: E501
|
|
if 'index' in params:
|
|
path_params['index'] = params['index'] # noqa: E501
|
|
|
|
query_params = []
|
|
if 'page' in params:
|
|
query_params.append(('page', params['page'])) # noqa: E501
|
|
if 'limit' in params:
|
|
query_params.append(('limit', params['limit'])) # 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
|
|
|
|
# HTTP header `Content-Type`
|
|
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
|
|
['application/json']) # noqa: E501
|
|
|
|
# Authentication setting
|
|
auth_settings = ['AccessToken', 'AuthorizationHeaderToken', 'BasicAuth', 'SudoHeader', 'SudoParam', 'TOTPHeader', 'Token'] # noqa: E501
|
|
|
|
return self.api_client.call_api(
|
|
'/repos/{owner}/{repo}/issues/{index}/reactions', 'GET',
|
|
path_params,
|
|
query_params,
|
|
header_params,
|
|
body=body_params,
|
|
post_params=form_params,
|
|
files=local_var_files,
|
|
response_type='list[Reaction]', # 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 issue_get_label(self, owner, repo, id, **kwargs): # noqa: E501
|
|
"""Get a single label # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_get_label(owner, repo, id, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param int id: id of the label to get (required)
|
|
:return: Label
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
kwargs['_return_http_data_only'] = True
|
|
if kwargs.get('async_req'):
|
|
return self.issue_get_label_with_http_info(owner, repo, id, **kwargs) # noqa: E501
|
|
else:
|
|
(data) = self.issue_get_label_with_http_info(owner, repo, id, **kwargs) # noqa: E501
|
|
return data
|
|
|
|
def issue_get_label_with_http_info(self, owner, repo, id, **kwargs): # noqa: E501
|
|
"""Get a single label # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_get_label_with_http_info(owner, repo, id, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param int id: id of the label to get (required)
|
|
:return: Label
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
|
|
all_params = ['owner', 'repo', 'id'] # 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 issue_get_label" % key
|
|
)
|
|
params[key] = val
|
|
del params['kwargs']
|
|
# verify the required parameter 'owner' is set
|
|
if self.api_client.client_side_validation and ('owner' not in params or
|
|
params['owner'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `owner` when calling `issue_get_label`") # noqa: E501
|
|
# verify the required parameter 'repo' is set
|
|
if self.api_client.client_side_validation and ('repo' not in params or
|
|
params['repo'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `repo` when calling `issue_get_label`") # noqa: E501
|
|
# verify the required parameter 'id' is set
|
|
if self.api_client.client_side_validation and ('id' not in params or
|
|
params['id'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `id` when calling `issue_get_label`") # noqa: E501
|
|
|
|
collection_formats = {}
|
|
|
|
path_params = {}
|
|
if 'owner' in params:
|
|
path_params['owner'] = params['owner'] # noqa: E501
|
|
if 'repo' in params:
|
|
path_params['repo'] = params['repo'] # noqa: E501
|
|
if 'id' in params:
|
|
path_params['id'] = params['id'] # noqa: E501
|
|
|
|
query_params = []
|
|
|
|
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
|
|
|
|
# HTTP header `Content-Type`
|
|
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
|
|
['application/json', 'text/plain']) # noqa: E501
|
|
|
|
# Authentication setting
|
|
auth_settings = ['AccessToken', 'AuthorizationHeaderToken', 'BasicAuth', 'SudoHeader', 'SudoParam', 'TOTPHeader', 'Token'] # noqa: E501
|
|
|
|
return self.api_client.call_api(
|
|
'/repos/{owner}/{repo}/labels/{id}', 'GET',
|
|
path_params,
|
|
query_params,
|
|
header_params,
|
|
body=body_params,
|
|
post_params=form_params,
|
|
files=local_var_files,
|
|
response_type='Label', # 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 issue_get_labels(self, owner, repo, index, **kwargs): # noqa: E501
|
|
"""Get an issue's labels # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_get_labels(owner, repo, index, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param int index: index of the issue (required)
|
|
:return: list[Label]
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
kwargs['_return_http_data_only'] = True
|
|
if kwargs.get('async_req'):
|
|
return self.issue_get_labels_with_http_info(owner, repo, index, **kwargs) # noqa: E501
|
|
else:
|
|
(data) = self.issue_get_labels_with_http_info(owner, repo, index, **kwargs) # noqa: E501
|
|
return data
|
|
|
|
def issue_get_labels_with_http_info(self, owner, repo, index, **kwargs): # noqa: E501
|
|
"""Get an issue's labels # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_get_labels_with_http_info(owner, repo, index, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param int index: index of the issue (required)
|
|
:return: list[Label]
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
|
|
all_params = ['owner', 'repo', 'index'] # 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 issue_get_labels" % key
|
|
)
|
|
params[key] = val
|
|
del params['kwargs']
|
|
# verify the required parameter 'owner' is set
|
|
if self.api_client.client_side_validation and ('owner' not in params or
|
|
params['owner'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `owner` when calling `issue_get_labels`") # noqa: E501
|
|
# verify the required parameter 'repo' is set
|
|
if self.api_client.client_side_validation and ('repo' not in params or
|
|
params['repo'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `repo` when calling `issue_get_labels`") # noqa: E501
|
|
# verify the required parameter 'index' is set
|
|
if self.api_client.client_side_validation and ('index' not in params or
|
|
params['index'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `index` when calling `issue_get_labels`") # noqa: E501
|
|
|
|
collection_formats = {}
|
|
|
|
path_params = {}
|
|
if 'owner' in params:
|
|
path_params['owner'] = params['owner'] # noqa: E501
|
|
if 'repo' in params:
|
|
path_params['repo'] = params['repo'] # noqa: E501
|
|
if 'index' in params:
|
|
path_params['index'] = params['index'] # noqa: E501
|
|
|
|
query_params = []
|
|
|
|
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
|
|
|
|
# HTTP header `Content-Type`
|
|
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
|
|
['application/json', 'text/plain']) # noqa: E501
|
|
|
|
# Authentication setting
|
|
auth_settings = ['AccessToken', 'AuthorizationHeaderToken', 'BasicAuth', 'SudoHeader', 'SudoParam', 'TOTPHeader', 'Token'] # noqa: E501
|
|
|
|
return self.api_client.call_api(
|
|
'/repos/{owner}/{repo}/issues/{index}/labels', 'GET',
|
|
path_params,
|
|
query_params,
|
|
header_params,
|
|
body=body_params,
|
|
post_params=form_params,
|
|
files=local_var_files,
|
|
response_type='list[Label]', # 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 issue_get_milestone(self, owner, repo, id, **kwargs): # noqa: E501
|
|
"""Get a milestone # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_get_milestone(owner, repo, id, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param str id: the milestone to get, identified by ID and if not available by name (required)
|
|
:return: Milestone
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
kwargs['_return_http_data_only'] = True
|
|
if kwargs.get('async_req'):
|
|
return self.issue_get_milestone_with_http_info(owner, repo, id, **kwargs) # noqa: E501
|
|
else:
|
|
(data) = self.issue_get_milestone_with_http_info(owner, repo, id, **kwargs) # noqa: E501
|
|
return data
|
|
|
|
def issue_get_milestone_with_http_info(self, owner, repo, id, **kwargs): # noqa: E501
|
|
"""Get a milestone # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_get_milestone_with_http_info(owner, repo, id, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param str id: the milestone to get, identified by ID and if not available by name (required)
|
|
:return: Milestone
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
|
|
all_params = ['owner', 'repo', 'id'] # 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 issue_get_milestone" % key
|
|
)
|
|
params[key] = val
|
|
del params['kwargs']
|
|
# verify the required parameter 'owner' is set
|
|
if self.api_client.client_side_validation and ('owner' not in params or
|
|
params['owner'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `owner` when calling `issue_get_milestone`") # noqa: E501
|
|
# verify the required parameter 'repo' is set
|
|
if self.api_client.client_side_validation and ('repo' not in params or
|
|
params['repo'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `repo` when calling `issue_get_milestone`") # noqa: E501
|
|
# verify the required parameter 'id' is set
|
|
if self.api_client.client_side_validation and ('id' not in params or
|
|
params['id'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `id` when calling `issue_get_milestone`") # noqa: E501
|
|
|
|
collection_formats = {}
|
|
|
|
path_params = {}
|
|
if 'owner' in params:
|
|
path_params['owner'] = params['owner'] # noqa: E501
|
|
if 'repo' in params:
|
|
path_params['repo'] = params['repo'] # noqa: E501
|
|
if 'id' in params:
|
|
path_params['id'] = params['id'] # noqa: E501
|
|
|
|
query_params = []
|
|
|
|
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
|
|
|
|
# HTTP header `Content-Type`
|
|
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
|
|
['application/json', 'text/plain']) # noqa: E501
|
|
|
|
# Authentication setting
|
|
auth_settings = ['AccessToken', 'AuthorizationHeaderToken', 'BasicAuth', 'SudoHeader', 'SudoParam', 'TOTPHeader', 'Token'] # noqa: E501
|
|
|
|
return self.api_client.call_api(
|
|
'/repos/{owner}/{repo}/milestones/{id}', 'GET',
|
|
path_params,
|
|
query_params,
|
|
header_params,
|
|
body=body_params,
|
|
post_params=form_params,
|
|
files=local_var_files,
|
|
response_type='Milestone', # 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 issue_get_milestones_list(self, owner, repo, **kwargs): # noqa: E501
|
|
"""Get all of a repository's opened milestones # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_get_milestones_list(owner, repo, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param str state: Milestone state, Recognized values are open, closed and all. Defaults to \"open\"
|
|
:param str name: filter by milestone name
|
|
:param int page: page number of results to return (1-based)
|
|
:param int limit: page size of results
|
|
:return: list[Milestone]
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
kwargs['_return_http_data_only'] = True
|
|
if kwargs.get('async_req'):
|
|
return self.issue_get_milestones_list_with_http_info(owner, repo, **kwargs) # noqa: E501
|
|
else:
|
|
(data) = self.issue_get_milestones_list_with_http_info(owner, repo, **kwargs) # noqa: E501
|
|
return data
|
|
|
|
def issue_get_milestones_list_with_http_info(self, owner, repo, **kwargs): # noqa: E501
|
|
"""Get all of a repository's opened milestones # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_get_milestones_list_with_http_info(owner, repo, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param str state: Milestone state, Recognized values are open, closed and all. Defaults to \"open\"
|
|
:param str name: filter by milestone name
|
|
:param int page: page number of results to return (1-based)
|
|
:param int limit: page size of results
|
|
:return: list[Milestone]
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
|
|
all_params = ['owner', 'repo', 'state', 'name', 'page', 'limit'] # 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 issue_get_milestones_list" % key
|
|
)
|
|
params[key] = val
|
|
del params['kwargs']
|
|
# verify the required parameter 'owner' is set
|
|
if self.api_client.client_side_validation and ('owner' not in params or
|
|
params['owner'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `owner` when calling `issue_get_milestones_list`") # noqa: E501
|
|
# verify the required parameter 'repo' is set
|
|
if self.api_client.client_side_validation and ('repo' not in params or
|
|
params['repo'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `repo` when calling `issue_get_milestones_list`") # noqa: E501
|
|
|
|
collection_formats = {}
|
|
|
|
path_params = {}
|
|
if 'owner' in params:
|
|
path_params['owner'] = params['owner'] # noqa: E501
|
|
if 'repo' in params:
|
|
path_params['repo'] = params['repo'] # noqa: E501
|
|
|
|
query_params = []
|
|
if 'state' in params:
|
|
query_params.append(('state', params['state'])) # noqa: E501
|
|
if 'name' in params:
|
|
query_params.append(('name', params['name'])) # noqa: E501
|
|
if 'page' in params:
|
|
query_params.append(('page', params['page'])) # noqa: E501
|
|
if 'limit' in params:
|
|
query_params.append(('limit', params['limit'])) # 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
|
|
|
|
# HTTP header `Content-Type`
|
|
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
|
|
['application/json', 'text/plain']) # noqa: E501
|
|
|
|
# Authentication setting
|
|
auth_settings = ['AccessToken', 'AuthorizationHeaderToken', 'BasicAuth', 'SudoHeader', 'SudoParam', 'TOTPHeader', 'Token'] # noqa: E501
|
|
|
|
return self.api_client.call_api(
|
|
'/repos/{owner}/{repo}/milestones', 'GET',
|
|
path_params,
|
|
query_params,
|
|
header_params,
|
|
body=body_params,
|
|
post_params=form_params,
|
|
files=local_var_files,
|
|
response_type='list[Milestone]', # 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 issue_get_repo_comments(self, owner, repo, **kwargs): # noqa: E501
|
|
"""List all comments in a repository # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_get_repo_comments(owner, repo, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param datetime since: if provided, only comments updated since the provided time are returned.
|
|
:param datetime before: if provided, only comments updated before the provided time are returned.
|
|
:param int page: page number of results to return (1-based)
|
|
:param int limit: page size of results
|
|
:return: list[Comment]
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
kwargs['_return_http_data_only'] = True
|
|
if kwargs.get('async_req'):
|
|
return self.issue_get_repo_comments_with_http_info(owner, repo, **kwargs) # noqa: E501
|
|
else:
|
|
(data) = self.issue_get_repo_comments_with_http_info(owner, repo, **kwargs) # noqa: E501
|
|
return data
|
|
|
|
def issue_get_repo_comments_with_http_info(self, owner, repo, **kwargs): # noqa: E501
|
|
"""List all comments in a repository # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_get_repo_comments_with_http_info(owner, repo, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param datetime since: if provided, only comments updated since the provided time are returned.
|
|
:param datetime before: if provided, only comments updated before the provided time are returned.
|
|
:param int page: page number of results to return (1-based)
|
|
:param int limit: page size of results
|
|
:return: list[Comment]
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
|
|
all_params = ['owner', 'repo', 'since', 'before', 'page', 'limit'] # 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 issue_get_repo_comments" % key
|
|
)
|
|
params[key] = val
|
|
del params['kwargs']
|
|
# verify the required parameter 'owner' is set
|
|
if self.api_client.client_side_validation and ('owner' not in params or
|
|
params['owner'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `owner` when calling `issue_get_repo_comments`") # noqa: E501
|
|
# verify the required parameter 'repo' is set
|
|
if self.api_client.client_side_validation and ('repo' not in params or
|
|
params['repo'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `repo` when calling `issue_get_repo_comments`") # noqa: E501
|
|
|
|
collection_formats = {}
|
|
|
|
path_params = {}
|
|
if 'owner' in params:
|
|
path_params['owner'] = params['owner'] # noqa: E501
|
|
if 'repo' in params:
|
|
path_params['repo'] = params['repo'] # noqa: E501
|
|
|
|
query_params = []
|
|
if 'since' in params:
|
|
query_params.append(('since', params['since'])) # noqa: E501
|
|
if 'before' in params:
|
|
query_params.append(('before', params['before'])) # noqa: E501
|
|
if 'page' in params:
|
|
query_params.append(('page', params['page'])) # noqa: E501
|
|
if 'limit' in params:
|
|
query_params.append(('limit', params['limit'])) # 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
|
|
|
|
# HTTP header `Content-Type`
|
|
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
|
|
['application/json', 'text/plain']) # noqa: E501
|
|
|
|
# Authentication setting
|
|
auth_settings = ['AccessToken', 'AuthorizationHeaderToken', 'BasicAuth', 'SudoHeader', 'SudoParam', 'TOTPHeader', 'Token'] # noqa: E501
|
|
|
|
return self.api_client.call_api(
|
|
'/repos/{owner}/{repo}/issues/comments', 'GET',
|
|
path_params,
|
|
query_params,
|
|
header_params,
|
|
body=body_params,
|
|
post_params=form_params,
|
|
files=local_var_files,
|
|
response_type='list[Comment]', # 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 issue_list_issues(self, owner, repo, **kwargs): # noqa: E501
|
|
"""List a repository's issues # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_list_issues(owner, repo, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param str state: whether issue is open or closed
|
|
:param str labels: comma separated list of labels. Fetch only issues that have any of this labels. Non existent labels are discarded
|
|
:param str q: search string
|
|
:param str type: filter by type (issues / pulls) if set
|
|
:param str milestones: comma separated list of milestone names or ids. It uses names and fall back to ids. Fetch only issues that have any of this milestones. Non existent milestones are discarded
|
|
:param datetime since: Only show items updated after the given time. This is a timestamp in RFC 3339 format
|
|
:param datetime before: Only show items updated before the given time. This is a timestamp in RFC 3339 format
|
|
:param str created_by: Only show items which were created by the the given user
|
|
:param str assigned_by: Only show items for which the given user is assigned
|
|
:param str mentioned_by: Only show items in which the given user was mentioned
|
|
:param int page: page number of results to return (1-based)
|
|
:param int limit: page size of results
|
|
:return: list[Issue]
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
kwargs['_return_http_data_only'] = True
|
|
if kwargs.get('async_req'):
|
|
return self.issue_list_issues_with_http_info(owner, repo, **kwargs) # noqa: E501
|
|
else:
|
|
(data) = self.issue_list_issues_with_http_info(owner, repo, **kwargs) # noqa: E501
|
|
return data
|
|
|
|
def issue_list_issues_with_http_info(self, owner, repo, **kwargs): # noqa: E501
|
|
"""List a repository's issues # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_list_issues_with_http_info(owner, repo, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param str state: whether issue is open or closed
|
|
:param str labels: comma separated list of labels. Fetch only issues that have any of this labels. Non existent labels are discarded
|
|
:param str q: search string
|
|
:param str type: filter by type (issues / pulls) if set
|
|
:param str milestones: comma separated list of milestone names or ids. It uses names and fall back to ids. Fetch only issues that have any of this milestones. Non existent milestones are discarded
|
|
:param datetime since: Only show items updated after the given time. This is a timestamp in RFC 3339 format
|
|
:param datetime before: Only show items updated before the given time. This is a timestamp in RFC 3339 format
|
|
:param str created_by: Only show items which were created by the the given user
|
|
:param str assigned_by: Only show items for which the given user is assigned
|
|
:param str mentioned_by: Only show items in which the given user was mentioned
|
|
:param int page: page number of results to return (1-based)
|
|
:param int limit: page size of results
|
|
:return: list[Issue]
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
|
|
all_params = ['owner', 'repo', 'state', 'labels', 'q', 'type', 'milestones', 'since', 'before', 'created_by', 'assigned_by', 'mentioned_by', 'page', 'limit'] # 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 issue_list_issues" % key
|
|
)
|
|
params[key] = val
|
|
del params['kwargs']
|
|
# verify the required parameter 'owner' is set
|
|
if self.api_client.client_side_validation and ('owner' not in params or
|
|
params['owner'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `owner` when calling `issue_list_issues`") # noqa: E501
|
|
# verify the required parameter 'repo' is set
|
|
if self.api_client.client_side_validation and ('repo' not in params or
|
|
params['repo'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `repo` when calling `issue_list_issues`") # noqa: E501
|
|
|
|
collection_formats = {}
|
|
|
|
path_params = {}
|
|
if 'owner' in params:
|
|
path_params['owner'] = params['owner'] # noqa: E501
|
|
if 'repo' in params:
|
|
path_params['repo'] = params['repo'] # noqa: E501
|
|
|
|
query_params = []
|
|
if 'state' in params:
|
|
query_params.append(('state', params['state'])) # noqa: E501
|
|
if 'labels' in params:
|
|
query_params.append(('labels', params['labels'])) # noqa: E501
|
|
if 'q' in params:
|
|
query_params.append(('q', params['q'])) # noqa: E501
|
|
if 'type' in params:
|
|
query_params.append(('type', params['type'])) # noqa: E501
|
|
if 'milestones' in params:
|
|
query_params.append(('milestones', params['milestones'])) # noqa: E501
|
|
if 'since' in params:
|
|
query_params.append(('since', params['since'])) # noqa: E501
|
|
if 'before' in params:
|
|
query_params.append(('before', params['before'])) # noqa: E501
|
|
if 'created_by' in params:
|
|
query_params.append(('created_by', params['created_by'])) # noqa: E501
|
|
if 'assigned_by' in params:
|
|
query_params.append(('assigned_by', params['assigned_by'])) # noqa: E501
|
|
if 'mentioned_by' in params:
|
|
query_params.append(('mentioned_by', params['mentioned_by'])) # noqa: E501
|
|
if 'page' in params:
|
|
query_params.append(('page', params['page'])) # noqa: E501
|
|
if 'limit' in params:
|
|
query_params.append(('limit', params['limit'])) # 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
|
|
|
|
# HTTP header `Content-Type`
|
|
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
|
|
['application/json', 'text/plain']) # noqa: E501
|
|
|
|
# Authentication setting
|
|
auth_settings = ['AccessToken', 'AuthorizationHeaderToken', 'BasicAuth', 'SudoHeader', 'SudoParam', 'TOTPHeader', 'Token'] # noqa: E501
|
|
|
|
return self.api_client.call_api(
|
|
'/repos/{owner}/{repo}/issues', 'GET',
|
|
path_params,
|
|
query_params,
|
|
header_params,
|
|
body=body_params,
|
|
post_params=form_params,
|
|
files=local_var_files,
|
|
response_type='list[Issue]', # 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 issue_list_labels(self, owner, repo, **kwargs): # noqa: E501
|
|
"""Get all of a repository's labels # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_list_labels(owner, repo, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param int page: page number of results to return (1-based)
|
|
:param int limit: page size of results
|
|
:return: list[Label]
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
kwargs['_return_http_data_only'] = True
|
|
if kwargs.get('async_req'):
|
|
return self.issue_list_labels_with_http_info(owner, repo, **kwargs) # noqa: E501
|
|
else:
|
|
(data) = self.issue_list_labels_with_http_info(owner, repo, **kwargs) # noqa: E501
|
|
return data
|
|
|
|
def issue_list_labels_with_http_info(self, owner, repo, **kwargs): # noqa: E501
|
|
"""Get all of a repository's labels # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_list_labels_with_http_info(owner, repo, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param int page: page number of results to return (1-based)
|
|
:param int limit: page size of results
|
|
:return: list[Label]
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
|
|
all_params = ['owner', 'repo', 'page', 'limit'] # 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 issue_list_labels" % key
|
|
)
|
|
params[key] = val
|
|
del params['kwargs']
|
|
# verify the required parameter 'owner' is set
|
|
if self.api_client.client_side_validation and ('owner' not in params or
|
|
params['owner'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `owner` when calling `issue_list_labels`") # noqa: E501
|
|
# verify the required parameter 'repo' is set
|
|
if self.api_client.client_side_validation and ('repo' not in params or
|
|
params['repo'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `repo` when calling `issue_list_labels`") # noqa: E501
|
|
|
|
collection_formats = {}
|
|
|
|
path_params = {}
|
|
if 'owner' in params:
|
|
path_params['owner'] = params['owner'] # noqa: E501
|
|
if 'repo' in params:
|
|
path_params['repo'] = params['repo'] # noqa: E501
|
|
|
|
query_params = []
|
|
if 'page' in params:
|
|
query_params.append(('page', params['page'])) # noqa: E501
|
|
if 'limit' in params:
|
|
query_params.append(('limit', params['limit'])) # 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
|
|
|
|
# HTTP header `Content-Type`
|
|
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
|
|
['application/json', 'text/plain']) # noqa: E501
|
|
|
|
# Authentication setting
|
|
auth_settings = ['AccessToken', 'AuthorizationHeaderToken', 'BasicAuth', 'SudoHeader', 'SudoParam', 'TOTPHeader', 'Token'] # noqa: E501
|
|
|
|
return self.api_client.call_api(
|
|
'/repos/{owner}/{repo}/labels', 'GET',
|
|
path_params,
|
|
query_params,
|
|
header_params,
|
|
body=body_params,
|
|
post_params=form_params,
|
|
files=local_var_files,
|
|
response_type='list[Label]', # 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 issue_post_comment_reaction(self, owner, repo, id, **kwargs): # noqa: E501
|
|
"""Add a reaction to a comment of an issue # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_post_comment_reaction(owner, repo, id, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param int id: id of the comment to edit (required)
|
|
:param EditReactionOption content:
|
|
:return: Reaction
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
kwargs['_return_http_data_only'] = True
|
|
if kwargs.get('async_req'):
|
|
return self.issue_post_comment_reaction_with_http_info(owner, repo, id, **kwargs) # noqa: E501
|
|
else:
|
|
(data) = self.issue_post_comment_reaction_with_http_info(owner, repo, id, **kwargs) # noqa: E501
|
|
return data
|
|
|
|
def issue_post_comment_reaction_with_http_info(self, owner, repo, id, **kwargs): # noqa: E501
|
|
"""Add a reaction to a comment of an issue # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_post_comment_reaction_with_http_info(owner, repo, id, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param int id: id of the comment to edit (required)
|
|
:param EditReactionOption content:
|
|
:return: Reaction
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
|
|
all_params = ['owner', 'repo', 'id', 'content'] # 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 issue_post_comment_reaction" % key
|
|
)
|
|
params[key] = val
|
|
del params['kwargs']
|
|
# verify the required parameter 'owner' is set
|
|
if self.api_client.client_side_validation and ('owner' not in params or
|
|
params['owner'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `owner` when calling `issue_post_comment_reaction`") # noqa: E501
|
|
# verify the required parameter 'repo' is set
|
|
if self.api_client.client_side_validation and ('repo' not in params or
|
|
params['repo'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `repo` when calling `issue_post_comment_reaction`") # noqa: E501
|
|
# verify the required parameter 'id' is set
|
|
if self.api_client.client_side_validation and ('id' not in params or
|
|
params['id'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `id` when calling `issue_post_comment_reaction`") # noqa: E501
|
|
|
|
collection_formats = {}
|
|
|
|
path_params = {}
|
|
if 'owner' in params:
|
|
path_params['owner'] = params['owner'] # noqa: E501
|
|
if 'repo' in params:
|
|
path_params['repo'] = params['repo'] # noqa: E501
|
|
if 'id' in params:
|
|
path_params['id'] = params['id'] # noqa: E501
|
|
|
|
query_params = []
|
|
|
|
header_params = {}
|
|
|
|
form_params = []
|
|
local_var_files = {}
|
|
|
|
body_params = None
|
|
if 'content' in params:
|
|
body_params = params['content']
|
|
# HTTP header `Accept`
|
|
header_params['Accept'] = self.api_client.select_header_accept(
|
|
['application/json']) # noqa: E501
|
|
|
|
# HTTP header `Content-Type`
|
|
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
|
|
['application/json']) # noqa: E501
|
|
|
|
# Authentication setting
|
|
auth_settings = ['AccessToken', 'AuthorizationHeaderToken', 'BasicAuth', 'SudoHeader', 'SudoParam', 'TOTPHeader', 'Token'] # noqa: E501
|
|
|
|
return self.api_client.call_api(
|
|
'/repos/{owner}/{repo}/issues/comments/{id}/reactions', 'POST',
|
|
path_params,
|
|
query_params,
|
|
header_params,
|
|
body=body_params,
|
|
post_params=form_params,
|
|
files=local_var_files,
|
|
response_type='Reaction', # 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 issue_post_issue_reaction(self, owner, repo, index, **kwargs): # noqa: E501
|
|
"""Add a reaction to an issue # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_post_issue_reaction(owner, repo, index, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param int index: index of the issue (required)
|
|
:param EditReactionOption content:
|
|
:return: Reaction
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
kwargs['_return_http_data_only'] = True
|
|
if kwargs.get('async_req'):
|
|
return self.issue_post_issue_reaction_with_http_info(owner, repo, index, **kwargs) # noqa: E501
|
|
else:
|
|
(data) = self.issue_post_issue_reaction_with_http_info(owner, repo, index, **kwargs) # noqa: E501
|
|
return data
|
|
|
|
def issue_post_issue_reaction_with_http_info(self, owner, repo, index, **kwargs): # noqa: E501
|
|
"""Add a reaction to an issue # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_post_issue_reaction_with_http_info(owner, repo, index, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param int index: index of the issue (required)
|
|
:param EditReactionOption content:
|
|
:return: Reaction
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
|
|
all_params = ['owner', 'repo', 'index', 'content'] # 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 issue_post_issue_reaction" % key
|
|
)
|
|
params[key] = val
|
|
del params['kwargs']
|
|
# verify the required parameter 'owner' is set
|
|
if self.api_client.client_side_validation and ('owner' not in params or
|
|
params['owner'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `owner` when calling `issue_post_issue_reaction`") # noqa: E501
|
|
# verify the required parameter 'repo' is set
|
|
if self.api_client.client_side_validation and ('repo' not in params or
|
|
params['repo'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `repo` when calling `issue_post_issue_reaction`") # noqa: E501
|
|
# verify the required parameter 'index' is set
|
|
if self.api_client.client_side_validation and ('index' not in params or
|
|
params['index'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `index` when calling `issue_post_issue_reaction`") # noqa: E501
|
|
|
|
collection_formats = {}
|
|
|
|
path_params = {}
|
|
if 'owner' in params:
|
|
path_params['owner'] = params['owner'] # noqa: E501
|
|
if 'repo' in params:
|
|
path_params['repo'] = params['repo'] # noqa: E501
|
|
if 'index' in params:
|
|
path_params['index'] = params['index'] # noqa: E501
|
|
|
|
query_params = []
|
|
|
|
header_params = {}
|
|
|
|
form_params = []
|
|
local_var_files = {}
|
|
|
|
body_params = None
|
|
if 'content' in params:
|
|
body_params = params['content']
|
|
# HTTP header `Accept`
|
|
header_params['Accept'] = self.api_client.select_header_accept(
|
|
['application/json']) # noqa: E501
|
|
|
|
# HTTP header `Content-Type`
|
|
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
|
|
['application/json']) # noqa: E501
|
|
|
|
# Authentication setting
|
|
auth_settings = ['AccessToken', 'AuthorizationHeaderToken', 'BasicAuth', 'SudoHeader', 'SudoParam', 'TOTPHeader', 'Token'] # noqa: E501
|
|
|
|
return self.api_client.call_api(
|
|
'/repos/{owner}/{repo}/issues/{index}/reactions', 'POST',
|
|
path_params,
|
|
query_params,
|
|
header_params,
|
|
body=body_params,
|
|
post_params=form_params,
|
|
files=local_var_files,
|
|
response_type='Reaction', # 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 issue_remove_label(self, owner, repo, index, id, **kwargs): # noqa: E501
|
|
"""Remove a label from an issue # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_remove_label(owner, repo, index, id, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param int index: index of the issue (required)
|
|
:param int id: id of the label to remove (required)
|
|
:return: None
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
kwargs['_return_http_data_only'] = True
|
|
if kwargs.get('async_req'):
|
|
return self.issue_remove_label_with_http_info(owner, repo, index, id, **kwargs) # noqa: E501
|
|
else:
|
|
(data) = self.issue_remove_label_with_http_info(owner, repo, index, id, **kwargs) # noqa: E501
|
|
return data
|
|
|
|
def issue_remove_label_with_http_info(self, owner, repo, index, id, **kwargs): # noqa: E501
|
|
"""Remove a label from an issue # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_remove_label_with_http_info(owner, repo, index, id, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param int index: index of the issue (required)
|
|
:param int id: id of the label to remove (required)
|
|
:return: None
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
|
|
all_params = ['owner', 'repo', 'index', 'id'] # 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 issue_remove_label" % key
|
|
)
|
|
params[key] = val
|
|
del params['kwargs']
|
|
# verify the required parameter 'owner' is set
|
|
if self.api_client.client_side_validation and ('owner' not in params or
|
|
params['owner'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `owner` when calling `issue_remove_label`") # noqa: E501
|
|
# verify the required parameter 'repo' is set
|
|
if self.api_client.client_side_validation and ('repo' not in params or
|
|
params['repo'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `repo` when calling `issue_remove_label`") # noqa: E501
|
|
# verify the required parameter 'index' is set
|
|
if self.api_client.client_side_validation and ('index' not in params or
|
|
params['index'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `index` when calling `issue_remove_label`") # noqa: E501
|
|
# verify the required parameter 'id' is set
|
|
if self.api_client.client_side_validation and ('id' not in params or
|
|
params['id'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `id` when calling `issue_remove_label`") # noqa: E501
|
|
|
|
collection_formats = {}
|
|
|
|
path_params = {}
|
|
if 'owner' in params:
|
|
path_params['owner'] = params['owner'] # noqa: E501
|
|
if 'repo' in params:
|
|
path_params['repo'] = params['repo'] # noqa: E501
|
|
if 'index' in params:
|
|
path_params['index'] = params['index'] # noqa: E501
|
|
if 'id' in params:
|
|
path_params['id'] = params['id'] # noqa: E501
|
|
|
|
query_params = []
|
|
|
|
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
|
|
|
|
# HTTP header `Content-Type`
|
|
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
|
|
['application/json', 'text/plain']) # noqa: E501
|
|
|
|
# Authentication setting
|
|
auth_settings = ['AccessToken', 'AuthorizationHeaderToken', 'BasicAuth', 'SudoHeader', 'SudoParam', 'TOTPHeader', 'Token'] # noqa: E501
|
|
|
|
return self.api_client.call_api(
|
|
'/repos/{owner}/{repo}/issues/{index}/labels/{id}', 'DELETE',
|
|
path_params,
|
|
query_params,
|
|
header_params,
|
|
body=body_params,
|
|
post_params=form_params,
|
|
files=local_var_files,
|
|
response_type=None, # 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 issue_replace_labels(self, owner, repo, index, **kwargs): # noqa: E501
|
|
"""Replace an issue's labels # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_replace_labels(owner, repo, index, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param int index: index of the issue (required)
|
|
:param IssueLabelsOption body:
|
|
:return: list[Label]
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
kwargs['_return_http_data_only'] = True
|
|
if kwargs.get('async_req'):
|
|
return self.issue_replace_labels_with_http_info(owner, repo, index, **kwargs) # noqa: E501
|
|
else:
|
|
(data) = self.issue_replace_labels_with_http_info(owner, repo, index, **kwargs) # noqa: E501
|
|
return data
|
|
|
|
def issue_replace_labels_with_http_info(self, owner, repo, index, **kwargs): # noqa: E501
|
|
"""Replace an issue's labels # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_replace_labels_with_http_info(owner, repo, index, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param int index: index of the issue (required)
|
|
:param IssueLabelsOption body:
|
|
:return: list[Label]
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
|
|
all_params = ['owner', 'repo', 'index', 'body'] # 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 issue_replace_labels" % key
|
|
)
|
|
params[key] = val
|
|
del params['kwargs']
|
|
# verify the required parameter 'owner' is set
|
|
if self.api_client.client_side_validation and ('owner' not in params or
|
|
params['owner'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `owner` when calling `issue_replace_labels`") # noqa: E501
|
|
# verify the required parameter 'repo' is set
|
|
if self.api_client.client_side_validation and ('repo' not in params or
|
|
params['repo'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `repo` when calling `issue_replace_labels`") # noqa: E501
|
|
# verify the required parameter 'index' is set
|
|
if self.api_client.client_side_validation and ('index' not in params or
|
|
params['index'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `index` when calling `issue_replace_labels`") # noqa: E501
|
|
|
|
collection_formats = {}
|
|
|
|
path_params = {}
|
|
if 'owner' in params:
|
|
path_params['owner'] = params['owner'] # noqa: E501
|
|
if 'repo' in params:
|
|
path_params['repo'] = params['repo'] # noqa: E501
|
|
if 'index' in params:
|
|
path_params['index'] = params['index'] # noqa: E501
|
|
|
|
query_params = []
|
|
|
|
header_params = {}
|
|
|
|
form_params = []
|
|
local_var_files = {}
|
|
|
|
body_params = None
|
|
if 'body' in params:
|
|
body_params = params['body']
|
|
# HTTP header `Accept`
|
|
header_params['Accept'] = self.api_client.select_header_accept(
|
|
['application/json']) # noqa: E501
|
|
|
|
# HTTP header `Content-Type`
|
|
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
|
|
['application/json']) # noqa: E501
|
|
|
|
# Authentication setting
|
|
auth_settings = ['AccessToken', 'AuthorizationHeaderToken', 'BasicAuth', 'SudoHeader', 'SudoParam', 'TOTPHeader', 'Token'] # noqa: E501
|
|
|
|
return self.api_client.call_api(
|
|
'/repos/{owner}/{repo}/issues/{index}/labels', 'PUT',
|
|
path_params,
|
|
query_params,
|
|
header_params,
|
|
body=body_params,
|
|
post_params=form_params,
|
|
files=local_var_files,
|
|
response_type='list[Label]', # 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 issue_reset_time(self, owner, repo, index, **kwargs): # noqa: E501
|
|
"""Reset a tracked time of an issue # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_reset_time(owner, repo, index, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param int index: index of the issue to add tracked time to (required)
|
|
:return: None
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
kwargs['_return_http_data_only'] = True
|
|
if kwargs.get('async_req'):
|
|
return self.issue_reset_time_with_http_info(owner, repo, index, **kwargs) # noqa: E501
|
|
else:
|
|
(data) = self.issue_reset_time_with_http_info(owner, repo, index, **kwargs) # noqa: E501
|
|
return data
|
|
|
|
def issue_reset_time_with_http_info(self, owner, repo, index, **kwargs): # noqa: E501
|
|
"""Reset a tracked time of an issue # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_reset_time_with_http_info(owner, repo, index, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param int index: index of the issue to add tracked time to (required)
|
|
:return: None
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
|
|
all_params = ['owner', 'repo', 'index'] # 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 issue_reset_time" % key
|
|
)
|
|
params[key] = val
|
|
del params['kwargs']
|
|
# verify the required parameter 'owner' is set
|
|
if self.api_client.client_side_validation and ('owner' not in params or
|
|
params['owner'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `owner` when calling `issue_reset_time`") # noqa: E501
|
|
# verify the required parameter 'repo' is set
|
|
if self.api_client.client_side_validation and ('repo' not in params or
|
|
params['repo'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `repo` when calling `issue_reset_time`") # noqa: E501
|
|
# verify the required parameter 'index' is set
|
|
if self.api_client.client_side_validation and ('index' not in params or
|
|
params['index'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `index` when calling `issue_reset_time`") # noqa: E501
|
|
|
|
collection_formats = {}
|
|
|
|
path_params = {}
|
|
if 'owner' in params:
|
|
path_params['owner'] = params['owner'] # noqa: E501
|
|
if 'repo' in params:
|
|
path_params['repo'] = params['repo'] # noqa: E501
|
|
if 'index' in params:
|
|
path_params['index'] = params['index'] # noqa: E501
|
|
|
|
query_params = []
|
|
|
|
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
|
|
|
|
# HTTP header `Content-Type`
|
|
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
|
|
['application/json']) # noqa: E501
|
|
|
|
# Authentication setting
|
|
auth_settings = ['AccessToken', 'AuthorizationHeaderToken', 'BasicAuth', 'SudoHeader', 'SudoParam', 'TOTPHeader', 'Token'] # noqa: E501
|
|
|
|
return self.api_client.call_api(
|
|
'/repos/{owner}/{repo}/issues/{index}/times', 'DELETE',
|
|
path_params,
|
|
query_params,
|
|
header_params,
|
|
body=body_params,
|
|
post_params=form_params,
|
|
files=local_var_files,
|
|
response_type=None, # 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 issue_search_issues(self, **kwargs): # noqa: E501
|
|
"""Search for issues across the repositories that the user has access to # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_search_issues(async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str state: whether issue is open or closed
|
|
:param str labels: comma separated list of labels. Fetch only issues that have any of this labels. Non existent labels are discarded
|
|
:param str milestones: comma separated list of milestone names. Fetch only issues that have any of this milestones. Non existent are discarded
|
|
:param str q: search string
|
|
:param int priority_repo_id: repository to prioritize in the results
|
|
:param str type: filter by type (issues / pulls) if set
|
|
:param datetime since: Only show notifications updated after the given time. This is a timestamp in RFC 3339 format
|
|
:param datetime before: Only show notifications updated before the given time. This is a timestamp in RFC 3339 format
|
|
:param bool assigned: filter (issues / pulls) assigned to you, default is false
|
|
:param bool created: filter (issues / pulls) created by you, default is false
|
|
:param bool mentioned: filter (issues / pulls) mentioning you, default is false
|
|
:param bool review_requested: filter pulls requesting your review, default is false
|
|
:param str owner: filter by owner
|
|
:param str team: filter by team (requires organization owner parameter to be provided)
|
|
:param int page: page number of results to return (1-based)
|
|
:param int limit: page size of results
|
|
:return: list[Issue]
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
kwargs['_return_http_data_only'] = True
|
|
if kwargs.get('async_req'):
|
|
return self.issue_search_issues_with_http_info(**kwargs) # noqa: E501
|
|
else:
|
|
(data) = self.issue_search_issues_with_http_info(**kwargs) # noqa: E501
|
|
return data
|
|
|
|
def issue_search_issues_with_http_info(self, **kwargs): # noqa: E501
|
|
"""Search for issues across the repositories that the user has access to # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_search_issues_with_http_info(async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str state: whether issue is open or closed
|
|
:param str labels: comma separated list of labels. Fetch only issues that have any of this labels. Non existent labels are discarded
|
|
:param str milestones: comma separated list of milestone names. Fetch only issues that have any of this milestones. Non existent are discarded
|
|
:param str q: search string
|
|
:param int priority_repo_id: repository to prioritize in the results
|
|
:param str type: filter by type (issues / pulls) if set
|
|
:param datetime since: Only show notifications updated after the given time. This is a timestamp in RFC 3339 format
|
|
:param datetime before: Only show notifications updated before the given time. This is a timestamp in RFC 3339 format
|
|
:param bool assigned: filter (issues / pulls) assigned to you, default is false
|
|
:param bool created: filter (issues / pulls) created by you, default is false
|
|
:param bool mentioned: filter (issues / pulls) mentioning you, default is false
|
|
:param bool review_requested: filter pulls requesting your review, default is false
|
|
:param str owner: filter by owner
|
|
:param str team: filter by team (requires organization owner parameter to be provided)
|
|
:param int page: page number of results to return (1-based)
|
|
:param int limit: page size of results
|
|
:return: list[Issue]
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
|
|
all_params = ['state', 'labels', 'milestones', 'q', 'priority_repo_id', 'type', 'since', 'before', 'assigned', 'created', 'mentioned', 'review_requested', 'owner', 'team', 'page', 'limit'] # 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 issue_search_issues" % key
|
|
)
|
|
params[key] = val
|
|
del params['kwargs']
|
|
|
|
collection_formats = {}
|
|
|
|
path_params = {}
|
|
|
|
query_params = []
|
|
if 'state' in params:
|
|
query_params.append(('state', params['state'])) # noqa: E501
|
|
if 'labels' in params:
|
|
query_params.append(('labels', params['labels'])) # noqa: E501
|
|
if 'milestones' in params:
|
|
query_params.append(('milestones', params['milestones'])) # noqa: E501
|
|
if 'q' in params:
|
|
query_params.append(('q', params['q'])) # noqa: E501
|
|
if 'priority_repo_id' in params:
|
|
query_params.append(('priority_repo_id', params['priority_repo_id'])) # noqa: E501
|
|
if 'type' in params:
|
|
query_params.append(('type', params['type'])) # noqa: E501
|
|
if 'since' in params:
|
|
query_params.append(('since', params['since'])) # noqa: E501
|
|
if 'before' in params:
|
|
query_params.append(('before', params['before'])) # noqa: E501
|
|
if 'assigned' in params:
|
|
query_params.append(('assigned', params['assigned'])) # noqa: E501
|
|
if 'created' in params:
|
|
query_params.append(('created', params['created'])) # noqa: E501
|
|
if 'mentioned' in params:
|
|
query_params.append(('mentioned', params['mentioned'])) # noqa: E501
|
|
if 'review_requested' in params:
|
|
query_params.append(('review_requested', params['review_requested'])) # noqa: E501
|
|
if 'owner' in params:
|
|
query_params.append(('owner', params['owner'])) # noqa: E501
|
|
if 'team' in params:
|
|
query_params.append(('team', params['team'])) # noqa: E501
|
|
if 'page' in params:
|
|
query_params.append(('page', params['page'])) # noqa: E501
|
|
if 'limit' in params:
|
|
query_params.append(('limit', params['limit'])) # 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
|
|
|
|
# HTTP header `Content-Type`
|
|
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
|
|
['application/json', 'text/plain']) # noqa: E501
|
|
|
|
# Authentication setting
|
|
auth_settings = ['AccessToken', 'AuthorizationHeaderToken', 'BasicAuth', 'SudoHeader', 'SudoParam', 'TOTPHeader', 'Token'] # noqa: E501
|
|
|
|
return self.api_client.call_api(
|
|
'/repos/issues/search', 'GET',
|
|
path_params,
|
|
query_params,
|
|
header_params,
|
|
body=body_params,
|
|
post_params=form_params,
|
|
files=local_var_files,
|
|
response_type='list[Issue]', # 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 issue_start_stop_watch(self, owner, repo, index, **kwargs): # noqa: E501
|
|
"""Start stopwatch on an issue. # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_start_stop_watch(owner, repo, index, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param int index: index of the issue to create the stopwatch on (required)
|
|
:return: None
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
kwargs['_return_http_data_only'] = True
|
|
if kwargs.get('async_req'):
|
|
return self.issue_start_stop_watch_with_http_info(owner, repo, index, **kwargs) # noqa: E501
|
|
else:
|
|
(data) = self.issue_start_stop_watch_with_http_info(owner, repo, index, **kwargs) # noqa: E501
|
|
return data
|
|
|
|
def issue_start_stop_watch_with_http_info(self, owner, repo, index, **kwargs): # noqa: E501
|
|
"""Start stopwatch on an issue. # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_start_stop_watch_with_http_info(owner, repo, index, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param int index: index of the issue to create the stopwatch on (required)
|
|
:return: None
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
|
|
all_params = ['owner', 'repo', 'index'] # 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 issue_start_stop_watch" % key
|
|
)
|
|
params[key] = val
|
|
del params['kwargs']
|
|
# verify the required parameter 'owner' is set
|
|
if self.api_client.client_side_validation and ('owner' not in params or
|
|
params['owner'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `owner` when calling `issue_start_stop_watch`") # noqa: E501
|
|
# verify the required parameter 'repo' is set
|
|
if self.api_client.client_side_validation and ('repo' not in params or
|
|
params['repo'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `repo` when calling `issue_start_stop_watch`") # noqa: E501
|
|
# verify the required parameter 'index' is set
|
|
if self.api_client.client_side_validation and ('index' not in params or
|
|
params['index'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `index` when calling `issue_start_stop_watch`") # noqa: E501
|
|
|
|
collection_formats = {}
|
|
|
|
path_params = {}
|
|
if 'owner' in params:
|
|
path_params['owner'] = params['owner'] # noqa: E501
|
|
if 'repo' in params:
|
|
path_params['repo'] = params['repo'] # noqa: E501
|
|
if 'index' in params:
|
|
path_params['index'] = params['index'] # noqa: E501
|
|
|
|
query_params = []
|
|
|
|
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
|
|
|
|
# HTTP header `Content-Type`
|
|
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
|
|
['application/json']) # noqa: E501
|
|
|
|
# Authentication setting
|
|
auth_settings = ['AccessToken', 'AuthorizationHeaderToken', 'BasicAuth', 'SudoHeader', 'SudoParam', 'TOTPHeader', 'Token'] # noqa: E501
|
|
|
|
return self.api_client.call_api(
|
|
'/repos/{owner}/{repo}/issues/{index}/stopwatch/start', 'POST',
|
|
path_params,
|
|
query_params,
|
|
header_params,
|
|
body=body_params,
|
|
post_params=form_params,
|
|
files=local_var_files,
|
|
response_type=None, # 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 issue_stop_stop_watch(self, owner, repo, index, **kwargs): # noqa: E501
|
|
"""Stop an issue's existing stopwatch. # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_stop_stop_watch(owner, repo, index, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param int index: index of the issue to stop the stopwatch on (required)
|
|
:return: None
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
kwargs['_return_http_data_only'] = True
|
|
if kwargs.get('async_req'):
|
|
return self.issue_stop_stop_watch_with_http_info(owner, repo, index, **kwargs) # noqa: E501
|
|
else:
|
|
(data) = self.issue_stop_stop_watch_with_http_info(owner, repo, index, **kwargs) # noqa: E501
|
|
return data
|
|
|
|
def issue_stop_stop_watch_with_http_info(self, owner, repo, index, **kwargs): # noqa: E501
|
|
"""Stop an issue's existing stopwatch. # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_stop_stop_watch_with_http_info(owner, repo, index, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param int index: index of the issue to stop the stopwatch on (required)
|
|
:return: None
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
|
|
all_params = ['owner', 'repo', 'index'] # 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 issue_stop_stop_watch" % key
|
|
)
|
|
params[key] = val
|
|
del params['kwargs']
|
|
# verify the required parameter 'owner' is set
|
|
if self.api_client.client_side_validation and ('owner' not in params or
|
|
params['owner'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `owner` when calling `issue_stop_stop_watch`") # noqa: E501
|
|
# verify the required parameter 'repo' is set
|
|
if self.api_client.client_side_validation and ('repo' not in params or
|
|
params['repo'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `repo` when calling `issue_stop_stop_watch`") # noqa: E501
|
|
# verify the required parameter 'index' is set
|
|
if self.api_client.client_side_validation and ('index' not in params or
|
|
params['index'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `index` when calling `issue_stop_stop_watch`") # noqa: E501
|
|
|
|
collection_formats = {}
|
|
|
|
path_params = {}
|
|
if 'owner' in params:
|
|
path_params['owner'] = params['owner'] # noqa: E501
|
|
if 'repo' in params:
|
|
path_params['repo'] = params['repo'] # noqa: E501
|
|
if 'index' in params:
|
|
path_params['index'] = params['index'] # noqa: E501
|
|
|
|
query_params = []
|
|
|
|
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
|
|
|
|
# HTTP header `Content-Type`
|
|
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
|
|
['application/json']) # noqa: E501
|
|
|
|
# Authentication setting
|
|
auth_settings = ['AccessToken', 'AuthorizationHeaderToken', 'BasicAuth', 'SudoHeader', 'SudoParam', 'TOTPHeader', 'Token'] # noqa: E501
|
|
|
|
return self.api_client.call_api(
|
|
'/repos/{owner}/{repo}/issues/{index}/stopwatch/stop', 'POST',
|
|
path_params,
|
|
query_params,
|
|
header_params,
|
|
body=body_params,
|
|
post_params=form_params,
|
|
files=local_var_files,
|
|
response_type=None, # 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 issue_subscriptions(self, owner, repo, index, **kwargs): # noqa: E501
|
|
"""Get users who subscribed on an issue. # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_subscriptions(owner, repo, index, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param int index: index of the issue (required)
|
|
:param int page: page number of results to return (1-based)
|
|
:param int limit: page size of results
|
|
:return: list[User]
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
kwargs['_return_http_data_only'] = True
|
|
if kwargs.get('async_req'):
|
|
return self.issue_subscriptions_with_http_info(owner, repo, index, **kwargs) # noqa: E501
|
|
else:
|
|
(data) = self.issue_subscriptions_with_http_info(owner, repo, index, **kwargs) # noqa: E501
|
|
return data
|
|
|
|
def issue_subscriptions_with_http_info(self, owner, repo, index, **kwargs): # noqa: E501
|
|
"""Get users who subscribed on an issue. # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_subscriptions_with_http_info(owner, repo, index, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param int index: index of the issue (required)
|
|
:param int page: page number of results to return (1-based)
|
|
:param int limit: page size of results
|
|
:return: list[User]
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
|
|
all_params = ['owner', 'repo', 'index', 'page', 'limit'] # 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 issue_subscriptions" % key
|
|
)
|
|
params[key] = val
|
|
del params['kwargs']
|
|
# verify the required parameter 'owner' is set
|
|
if self.api_client.client_side_validation and ('owner' not in params or
|
|
params['owner'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `owner` when calling `issue_subscriptions`") # noqa: E501
|
|
# verify the required parameter 'repo' is set
|
|
if self.api_client.client_side_validation and ('repo' not in params or
|
|
params['repo'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `repo` when calling `issue_subscriptions`") # noqa: E501
|
|
# verify the required parameter 'index' is set
|
|
if self.api_client.client_side_validation and ('index' not in params or
|
|
params['index'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `index` when calling `issue_subscriptions`") # noqa: E501
|
|
|
|
collection_formats = {}
|
|
|
|
path_params = {}
|
|
if 'owner' in params:
|
|
path_params['owner'] = params['owner'] # noqa: E501
|
|
if 'repo' in params:
|
|
path_params['repo'] = params['repo'] # noqa: E501
|
|
if 'index' in params:
|
|
path_params['index'] = params['index'] # noqa: E501
|
|
|
|
query_params = []
|
|
if 'page' in params:
|
|
query_params.append(('page', params['page'])) # noqa: E501
|
|
if 'limit' in params:
|
|
query_params.append(('limit', params['limit'])) # 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
|
|
|
|
# HTTP header `Content-Type`
|
|
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
|
|
['application/json']) # noqa: E501
|
|
|
|
# Authentication setting
|
|
auth_settings = ['AccessToken', 'AuthorizationHeaderToken', 'BasicAuth', 'SudoHeader', 'SudoParam', 'TOTPHeader', 'Token'] # noqa: E501
|
|
|
|
return self.api_client.call_api(
|
|
'/repos/{owner}/{repo}/issues/{index}/subscriptions', 'GET',
|
|
path_params,
|
|
query_params,
|
|
header_params,
|
|
body=body_params,
|
|
post_params=form_params,
|
|
files=local_var_files,
|
|
response_type='list[User]', # 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 issue_tracked_times(self, owner, repo, index, **kwargs): # noqa: E501
|
|
"""List an issue's tracked times # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_tracked_times(owner, repo, index, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param int index: index of the issue (required)
|
|
:param str user: optional filter by user (available for issue managers)
|
|
:param datetime since: Only show times updated after the given time. This is a timestamp in RFC 3339 format
|
|
:param datetime before: Only show times updated before the given time. This is a timestamp in RFC 3339 format
|
|
:param int page: page number of results to return (1-based)
|
|
:param int limit: page size of results
|
|
:return: list[TrackedTime]
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
kwargs['_return_http_data_only'] = True
|
|
if kwargs.get('async_req'):
|
|
return self.issue_tracked_times_with_http_info(owner, repo, index, **kwargs) # noqa: E501
|
|
else:
|
|
(data) = self.issue_tracked_times_with_http_info(owner, repo, index, **kwargs) # noqa: E501
|
|
return data
|
|
|
|
def issue_tracked_times_with_http_info(self, owner, repo, index, **kwargs): # noqa: E501
|
|
"""List an issue's tracked times # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
>>> thread = api.issue_tracked_times_with_http_info(owner, repo, index, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param async_req bool
|
|
:param str owner: owner of the repo (required)
|
|
:param str repo: name of the repo (required)
|
|
:param int index: index of the issue (required)
|
|
:param str user: optional filter by user (available for issue managers)
|
|
:param datetime since: Only show times updated after the given time. This is a timestamp in RFC 3339 format
|
|
:param datetime before: Only show times updated before the given time. This is a timestamp in RFC 3339 format
|
|
:param int page: page number of results to return (1-based)
|
|
:param int limit: page size of results
|
|
:return: list[TrackedTime]
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
"""
|
|
|
|
all_params = ['owner', 'repo', 'index', 'user', 'since', 'before', 'page', 'limit'] # 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 issue_tracked_times" % key
|
|
)
|
|
params[key] = val
|
|
del params['kwargs']
|
|
# verify the required parameter 'owner' is set
|
|
if self.api_client.client_side_validation and ('owner' not in params or
|
|
params['owner'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `owner` when calling `issue_tracked_times`") # noqa: E501
|
|
# verify the required parameter 'repo' is set
|
|
if self.api_client.client_side_validation and ('repo' not in params or
|
|
params['repo'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `repo` when calling `issue_tracked_times`") # noqa: E501
|
|
# verify the required parameter 'index' is set
|
|
if self.api_client.client_side_validation and ('index' not in params or
|
|
params['index'] is None): # noqa: E501
|
|
raise ValueError("Missing the required parameter `index` when calling `issue_tracked_times`") # noqa: E501
|
|
|
|
collection_formats = {}
|
|
|
|
path_params = {}
|
|
if 'owner' in params:
|
|
path_params['owner'] = params['owner'] # noqa: E501
|
|
if 'repo' in params:
|
|
path_params['repo'] = params['repo'] # noqa: E501
|
|
if 'index' in params:
|
|
path_params['index'] = params['index'] # noqa: E501
|
|
|
|
query_params = []
|
|
if 'user' in params:
|
|
query_params.append(('user', params['user'])) # noqa: E501
|
|
if 'since' in params:
|
|
query_params.append(('since', params['since'])) # noqa: E501
|
|
if 'before' in params:
|
|
query_params.append(('before', params['before'])) # noqa: E501
|
|
if 'page' in params:
|
|
query_params.append(('page', params['page'])) # noqa: E501
|
|
if 'limit' in params:
|
|
query_params.append(('limit', params['limit'])) # 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
|
|
|
|
# HTTP header `Content-Type`
|
|
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
|
|
['application/json', 'text/plain']) # noqa: E501
|
|
|
|
# Authentication setting
|
|
auth_settings = ['AccessToken', 'AuthorizationHeaderToken', 'BasicAuth', 'SudoHeader', 'SudoParam', 'TOTPHeader', 'Token'] # noqa: E501
|
|
|
|
return self.api_client.call_api(
|
|
'/repos/{owner}/{repo}/issues/{index}/times', 'GET',
|
|
path_params,
|
|
query_params,
|
|
header_params,
|
|
body=body_params,
|
|
post_params=form_params,
|
|
files=local_var_files,
|
|
response_type='list[TrackedTime]', # 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)
|