Get actual issues in the journal.
334576
def get_issues():
        """"""
        issues = []
        for entry in Logger.journal:
            if entry.level >= WARNING:
                issues.append(entry)
        return issues
208812
def relevant_issues(issues, after):
    """"""
    logging.info('finding relevant issues after {}...'.format(after))
    seen = set()
    for issue in issues:
        if relevent_issue(issue, after) and issue['title'] not in seen:
            seen.add(issue['title'])
            yield issue
522892
def latex(self):
        """"""
        s = ('{authors}, \\textit{{{title}}}, {journal}, {volissue}, '
             '{pages}, ({date}). {doi}, {scopus_url}.')
        if len(self.authors) > 1:
            authors = ', '.join([str(a.given_name) +
                                 ' ' + str(a.surname)
                                 for a in self.authors[0:-1]])
            authors += (' and ' +
                        str(self.authors[-1].given_name) +
                        ' ' + str(self.authors[-1].surname))
        else:
            a = self.authors[0]
            authors = str(a.given_name) + ' ' + str(a.surname)
        title = self.title
        journal = self.publicationName
        volume = self.volume
        issue = self.issueIdentifier
        if volume and issue:
            volissue = '\\textbf{{{0}({1})}}'.format(volume, issue)
        elif volume:
            volissue = '\\textbf{{0}}'.format(volume)
        else:
            volissue = 'no volume'
        date = self.coverDate
        if self.pageRange:
            pages = 'p. {0}'.format(self.pageRange)
        elif self.startingPage:
            pages = 'p. {self.startingPage}'.format(self)
        elif self.article_number:
            pages = 'Art. No. {self.article_number}, '.format(self)
        else:
            pages = '(no pages found)'
        doi = '\\href{{https://doi.org/{0}}}{{doi:{0}}}'.format(self.doi)
        scopus_url = '\\href{{{0}}}{{scopus:{1}}}'.format(self.scopus_url,
                                                          self.eid)

        return s.format(**locals())
125988
def issues(self, kind, email):
        
        return list(set([unicode(activity.issue)
            for activity in self.activities()
            if kind == activity.kind and activity.user['email'] == email]))
840757
def detect_actual_closed_dates(issues)
      print "Fetching closed dates for issues...\r" if options[:verbose]

      i = 0
      issues.each do |issue|
        find_closed_date_by_commit(issue)
        i += 1
      end
      puts "Fetching closed dates for issues: #{i}/#{issues.count}" if options[:verbose]
    end
329528
def etag(self):
        """"""
        if self.is_fake:
            return

        entry = None
        for entry in self.journal.list():
            pass

        return entry.uid if entry is not None else hashlib.sha256(b"").hexdigest()
508561
def list_issues(context, id, sort, limit):
    

    result = component.list_issues(context, id=id, sort=sort, limit=limit)
    headers = ['id', 'status', 'product', 'component', 'title', 'url']
    utils.format_output(result, context.format, headers)
518072
def retrieve_info(self):
        """"""

        path = urlparse(self.url).path
        path = path.split('/')[1:]

        sanity_filter = re.compile('[\da-z-_]+', re.IGNORECASE)
        self.product = sanity_filter.match(path[0]).group(0)
        self.component = sanity_filter.match(path[1]).group(0)
        self.issue_id = int(path[3])

        github_url = '%s/%s/%s/issues/%s' % (_URL_BASE,
                                             self.product,
                                             self.component,
                                             self.issue_id)

        result = requests.get(github_url)
        self.status_code = result.status_code

        if result.status_code == 200:
            result = result.json()
            self.title = result['title']
            self.reporter = result['user']['login']
            if result['assignee'] is not None:
                self.assignee = result['assignee']['login']
            self.status = result['state']
            self.created_at = result['created_at']
            self.updated_at = result['updated_at']
            self.closed_at = result['closed_at']
        elif result.status_code == 404:
            self.title = 'private issue'
1176900
def journals(self):
        
        try:
            target = self._item_path
            json_data = self._redmine.get(target % str(self.id),
                                          parms={'include': 'journals'})
            data = self._redmine.unwrap_json(None, json_data)
            journals = [Journal(redmine=self._redmine,
                                data=journal,
                                type='issue_journal')
                        for journal in data['issue']['journals']]

            return journals

        except Exception:
            return []
364556
def issue_tags(issue):
    """"""
    labels = issue.get('labels', [])
    return [label['name'].replace('tag: ', '') for label in labels if label['name'].startswith('tag: ')]
560298
synchronized Collection<Journal> getJournals() {
    Collection<Journal> journals = new ArrayList<Journal>();
    for (Journal j : journalsById.values()) {
      journals.add(j);
    }
    return journals;
  }
219916
def removed_issues(self, board_id, sprint_id):
        """"""
        r_json = self._get_json('rapid/charts/sprintreport?rapidViewId=%s&sprintId=%s' % (board_id, sprint_id),
                                base=self.AGILE_BASE_URL)
        issues = [Issue(self._options, self._session, raw_issues_json) for raw_issues_json in
                  r_json['contents']['puntedIssues']]

        return issues
1146976
def drafts(self):
        """"""
        pub = self.on_site().filter(status=self.model.DRAFT)
        if settings.PAGE_SHOW_START_DATE:
            pub = pub.filter(publication_date__gte=get_now())
        return pub
433030
def get_issue_comments(self):
        
        return github.PaginatedList.PaginatedList(
            github.IssueComment.IssueComment,
            self._requester,
            self.issue_url + "/comments",
            None
        )
1094787
def issue_section(issue):
    """"""
    labels = issue.get('labels', [])
    for label in labels:
        if not label['name'].startswith('type: '):
            continue

        if label['name'] in LOG_SECTION:
            return LOG_SECTION[label['name']]
        elif label['name'] in IGNORE_ISSUE_TYPE:
            return None
        else:
            logging.warning('unknown issue type: "{}" for: {}'.format(label['name'], issue_line(issue)))

    return None
512286
def get_results():
    """"""
    # store info in a dictionary {name -> shortname}
    res = {}
    session = requests.Session()
    handle_url('http://www.gocomics.com/features', session, res)
    handle_url('http://www.gocomics.com/explore/espanol', session, res)
    handle_url('http://www.gocomics.com/explore/editorial_list', session, res)
    handle_url('http://www.gocomics.com/explore/sherpa_list', session, res)
    save_result(res, json_file)
217587
public function getIssues()
	{
		if ( isset($this->result['issues']) ) {
			$result = array();

			foreach ( $this->result['issues'] as $issue ) {
				$result[] = new Issue($issue);
			}

			return $result;
		}

		return array();
	}