Return the notes section of the report.

        .. versionadded:: 3.5

        :return: The notes that should be attached to this impact report.
        :rtype: list
186805
def notes(self):
        
        fields = []  # Notes still to be defined for ASH
        # include any generic exposure specific notes from definitions
        fields = fields + self.exposure_notes()
        # include any generic hazard specific notes from definitions
        fields = fields + self.hazard_notes()

        # include any hazard/exposure notes from definitions
        exposure = definition(self.exposure.keywords.get('exposure'))
        hazard = definition(self.hazard.keywords.get('hazard'))
        fields.extend(specific_notes(hazard, exposure))

        if self._earthquake_function is not None:
            # Get notes specific to the fatality model
            for fatality_model in EARTHQUAKE_FUNCTIONS:
                if fatality_model['key'] == self._earthquake_function:
                    fields.extend(fatality_model.get('notes', []))

        return fields
185485
def get_section_metrics(cls):
        

        return {
            "overview": {
                "activity_metrics": [Closed, Submitted],
                "author_metrics": None,
                "bmi_metrics": [BMI],
                "time_to_close_metrics": [DaysToMergeMedian],
                "projects_metrics": [Projects],
            },
            "com_channels": {
                "activity_metrics": [],
                "author_metrics": []
            },
            "project_activity": {
                "metrics": [Submitted, Closed]
            },
            "project_community": {
                "author_metrics": [],
                "people_top_metrics": [],
                "orgs_top_metrics": [],
            },
            "project_process": {
                "bmi_metrics": [BMI],
                "time_to_close_metrics": [],
                "time_to_close_title": "",
                "time_to_close_review_metrics": [DaysToMergeAverage, DaysToMergeMedian],
                "time_to_close_review_title": "Days to close review (median and average)",
                "patchsets_metrics": [PatchsetsMedian, PatchsetsAverage],
                "patchsets_title": "Number of patchsets per review (median and average)"
            }
        }
1035735
def legacy_notes_view(request):
    
    notes = TeacherNote.objects.all()
    note_count = notes.count()
    paginator = Paginator(notes, 100)

    page = request.GET.get('page')
    try:
        notes = paginator.page(page)
    except PageNotAnInteger:
        notes = paginator.page(1)
    except EmptyPage:
        notes = paginator.page(paginator.num_pages)
    return render_to_response(
        'teacher_notes.html',
        {'page_name': "Legacy Notes",
         'notes': notes,
         'note_count': note_count,},
        context_instance=RequestContext(request)
    )
749782
def getContactItems(self, person):
        
        notes = list(person.store.query(Notes, Notes.person == person))
        if not notes:
            return [Notes(store=person.store,
                          person=person,
                          notes=u'')]
        return notes
1367940
protected function displayNotes()
    {
        $notes = array();

        if ($this->note !== null) {
            $note = new SwatMessage($this->note);
            $note->content_type = $this->note_content_type;
            $notes[] = $note;
        }

        $control = $this->getFirstDescendant('SwatControl');
        if ($control !== null) {
            $note = $control->getNote();
            if ($note !== null) {
                $notes[] = $note;
            }
        }

        if (count($notes) === 1) {
            $note = reset($notes);
            $note_div = new SwatHtmlTag('div');
            $note_div->class = 'swat-note';
            $note_div->setContent($note->primary_content, $note->content_type);
            $note_div->display();
        } elseif (count($notes) > 1) {
            $note_list = new SwatHtmlTag('ul');
            $note_list->class = 'swat-note';
            $note_list->open();

            $li_tag = new SwatHtmlTag('li');
            foreach ($notes as $note) {
                $li_tag->setContent(
                    $note->primary_content,
                    $note->content_type
                );

                $li_tag->display();
            }

            $note_list->close();
        }
    }
792321
def get_notes(self, folderid="", offset=0, limit=10):

        

        if self.standard_grant_type is not "authorization_code":
            raise DeviantartError("Authentication through Authorization Code (Grant Type) is required in order to connect to this endpoint.")

        response = self._req('/notes', {
            'folderid' : folderid,
            'offset' : offset,
            'limit' : limit
        })

        notes = []

        for item in response['results']:
            n = {}

            n['noteid'] = item['noteid']
            n['ts'] = item['ts']
            n['unread'] = item['unread']
            n['starred'] = item['starred']
            n['sent'] = item['sent']
            n['subject'] = item['subject']
            n['preview'] = item['preview']
            n['body'] = item['body']
            n['user'] = User()
            n['user'].from_dict(item['user'])
            n['recipients'] = []

            for recipient_item in item['recipients']:
                u = User()
                u.from_dict(recipient_item)
                n['recipients'].append(u)

            notes.append(n)

        return {
            "results" : notes,
            "has_more" : response['has_more'],
            "next_offset" : response['next_offset']
        }
595306
def render(self):
        
        release_notes = []
        for parser in self.parsers:
            parser_content = parser.render()
            if parser_content is not None:
                release_notes.append(parser_content)
        return u"\r\n\r\n".join(release_notes)
395487
def citations(self):
        

        if hasattr(self, 'citedReferences'):
            return [cr.ayjid for cr in self.citedReferences if cr is not None]
        return []
986581
def _format_notes(self, record):
        
        notes = []

        if "notes" in record:
            for note in record["notes"]:
                self._append_note_dict_to_list(notes, "general", note)

        if "language_and_script_notes" in record:
            self._append_note_dict_to_list(
                notes, "language_and_script", record["language_and_script_notes"]
            )

        if "publication_notes" in record:
            self._append_note_dict_to_list(
                notes, "publication_notes", record["publication_notes"]
            )

        if "physical_characteristics_and_technical_requirements" in record:
            self._append_note_dict_to_list(
                notes,
                "physical_condition",
                record["physical_characteristics_and_technical_requirements"],
            )

        return notes
237013
def full_author_notes(soup, fntype_filter=None):
    
    notes = []

    author_notes_section = raw_parser.author_notes(soup)
    if author_notes_section:
        fn_nodes = raw_parser.fn(author_notes_section)
        notes = footnotes(fn_nodes, fntype_filter)

    return notes
721216
def getcomments(self):
        
        comment_list = self.bugzilla.get_comments([self.bug_id])
        return comment_list['bugs'][str(self.bug_id)]['comments']
505695
def remove_duplicate_notes(self):
        """"""
        res = []
        for x in self.notes:
            if x not in res:
                res.append(x)
        self.notes = res
        return res
717831
def note(id, type, feature)
      _notes
      @_notes[id][type] = RSS_Note.new(id, type, feature)
    end
299056
def process_notes(notes, ref_data):
    '''
    '''

    ref_keys = ref_data.keys()

    found_refs = set()
    for k in ref_keys:
        if k in notes:
            found_refs.add(k)

    # The block to append
    reference_sec = '\n\n'
    reference_sec += '-------------------------------------------------\n'
    reference_sec += ' REFERENCES MENTIONED ABOVE\n'
    reference_sec += ' (not necessarily references for the basis sets)\n'
    reference_sec += '-------------------------------------------------\n'

    # Add reference data
    if len(found_refs) == 0:
        return notes

    for r in sorted(found_refs):
        rtxt = references.reference_text(ref_data[r])
        reference_sec += r + '\n'
        reference_sec += textwrap.indent(rtxt, ' ' * 4)
        reference_sec += '\n\n'

    return notes + reference_sec
1191042
def notes_for_version(self, version):
    
    branch_name = self._branch_name(version)
    branch_notes_file = self._branch_notes.get(branch_name, None)
    if branch_notes_file is None:
      raise ValueError(
          'Version {} lives in branch {}, which is not configured in {}.'.format(
            version, branch_name, self._branch_notes))
    return _read_contents(branch_notes_file)
975929
private String getNotes(List<MapRow> rows)
   {
      String result = null;
      if (rows != null && !rows.isEmpty())
      {
         StringBuilder sb = new StringBuilder();
         for (MapRow row : rows)
         {
            sb.append(row.getString("TITLE"));
            sb.append('\n');
            sb.append(row.getString("TEXT"));
            sb.append("\n\n");
         }
         result = sb.toString();
      }
      return result;
   }
164336
def get_section_marks(self):
        """"""
        return [abc if s in self.sec2chr else "." for s, abc in self.datobj.sec2chr.items()]