Get info about a single issue.
        :param issue_id: the id of the issue
        :return:
424430
def issue_info(self, issue_id):
        
        request_url = "{}issue/{}".format(self.create_basic_url(), issue_id)

        return_value = self._call_api(request_url)

        return return_value
1178321
def get_issue(self, branch):
        
        if branch:
            try:
                issue = self.issue(branch, expand='changelog')
                return issue
            except jira.exceptions.JIRAError as ex:
                if ex.status_code == 404:
                    print "No JIRA issue found for branch %s" % branch
                else:
                    print str(ex)
313083
def _format_issue(issue):
    '''
    
    '''
    ret = {'id': issue.get('id'),
           'issue_number': issue.get('number'),
           'state': issue.get('state'),
           'title': issue.get('title'),
           'user': issue.get('user').get('login'),
           'html_url': issue.get('html_url')}

    assignee = issue.get('assignee')
    if assignee:
        assignee = assignee.get('login')

    labels = issue.get('labels')
    label_names = []
    for label in labels:
        label_names.append(label.get('name'))

    milestone = issue.get('milestone')
    if milestone:
        milestone = milestone.get('title')

    ret['assignee'] = assignee
    ret['labels'] = label_names
    ret['milestone'] = milestone

    return ret
1306776
def get_articles(self, issue=''):
        	
		
		
	soup = get_soup() # get soup of all articles 
	issues = soup.find_all('ul')
		
	# validating and assigning default value for issue
	if not type(issue) is int or issue < 0 :
		issue = 1
	if issue > len(issues):
		issue = len(issues)		
		
	# considering latest article is last element 		
	articles = issues[len(issues)-issue].find_all('a') 
	mArticles = []
	for article in articles:
		mArticle = {}
		mArticle['link'] = article.get('href')[1:]
		mArticle['title'] = article.find('li').contents[0].strip()
		mArticle['author'] = article.find('span').contents[0].encode('utf8')
		mArticles.append(mArticle)
	return mArticles
1093019
def get_sla_by_id(self, issue_id_or_key, sla_id):
        
        url = 'rest/servicedeskapi/request/{0}/sla/{1}'.format(issue_id_or_key, sla_id)

        return self.get(url)
158007
def get_issue(self, number):
        
        assert isinstance(number, (int, long)), number
        headers, data = self._requester.requestJsonAndCheck(
            "GET",
            self.url + "/issues/" + str(number)
        )
        return github.Issue.Issue(self._requester, headers, data, completed=True)
1083072
def get(issue_id, issue_type_id):
        
        return db.Issue.find_one(
            Issue.issue_id == issue_id,
            Issue.issue_type_id == issue_type_id
        )
188022
def fetch_issues(jql, suppress_exceptions = false)
      client.Issue.jql(jql)
    rescue StandardError => e
      throw e unless suppress_exceptions
      nil
    end
1288543
def delete_issue_link(self, id):
        
        url = self._get_url('issueLink') + "/" + id
        return self._session.delete(url)
97815
def add_issue_comment(self, issue_id_or_key, content, extra_request_params={}):
        
        request_params = extra_request_params
        request_params["content"] = content
        return self.do("POST", "issues/{issue_id_or_key}/comments",
                       url_params={"issue_id_or_key": issue_id_or_key},
                       request_params=request_params,
                       )
604679
def issuetypes(accountable, project_key):
    
    projects = accountable.issue_types(project_key)
    headers = sorted(['id', 'name', 'description'])
    rows = []
    for key, issue_types in sorted(projects.items()):
        for issue_type in issue_types:
            rows.append(
                [key] + [v for k, v in sorted(issue_type.items())
                         if k in headers]
            )
    rows.insert(0, ['project_key'] + headers)
    print_table(SingleTable(rows))
59961
def get_component_related_issues(self, component_id):
        
        url = 'rest/api/2/component/{component_id}/relatedIssueCounts'.format(component_id=component_id)
        return self.get(url)
371625
def get_connection_status(self, connection_id):
        
        with self._connections_lock:
            try:
                connection_info = self._connections[connection_id]
                return connection_info.status
            except KeyError:
                return None
18324
def issue(self, issue_instance_id):
        
        with self.db.make_session() as session:
            selected_issue = (
                session.query(IssueInstance)
                .filter(IssueInstance.id == issue_instance_id)
                .scalar()
            )

            if selected_issue is None:
                self.warning(
                    f"Issue {issue_instance_id} doesn't exist. "
                    "Type 'issues' for available issues."
                )
                return

            self.sources = self._get_leaves_issue_instance(
                session, issue_instance_id, SharedTextKind.SOURCE
            )

            self.sinks = self._get_leaves_issue_instance(
                session, issue_instance_id, SharedTextKind.SINK
            )

        self.current_issue_instance_id = int(selected_issue.id)
        self.current_frame_id = -1
        self.current_trace_frame_index = 1  # first one after the source

        print(f"Set issue to {issue_instance_id}.")
        if int(selected_issue.run_id) != self.current_run_id:
            self.current_run_id = int(selected_issue.run_id)
            print(f"Set run to {self.current_run_id}.")
        print()

        self._generate_trace_from_issue()
        self.show()
1251798
def change_issue_milestone(self, issue_id, milestone):
        
        request_url = "{}issue/{}/milestone".format(self.create_basic_url(),
                                                    issue_id)

        payload = {} if milestone is None else {'milestone': milestone}

        return_value = self._call_api(request_url,
                                      method='POST', data=payload)

        LOG.debug(return_value)
1233629
def load_problem_details(id)
    return unless Problem[id].published.nil?

    html = open("https://projecteuler.net/problem=#{id}")
    fragment = Nokogiri::HTML(html)

    problem_info = fragment.css('div#problem_info span span')

    details = problem_info.text.split(';')
    Problem[id].published = details[0].strip
    Problem[id].solved_by = details[1].strip

    # recent problems do not have a difficult rating
    Problem[id].difficulty = details[2].strip if id <= Problem.total - 10
  end
528714
def comment_issue(self, issue_id, body):
        
        request_url = "{}issue/{}/comment".format(self.create_basic_url(),
                                                  issue_id)

        payload = {'comment': body}

        return_value = self._call_api(request_url,
                                      method='POST', data=payload)

        LOG.debug(return_value)