Return a list of all the presentation summaries contained in this page
503937
def summaries(self):
        """"""
        def create_summary(div):
            def get_id(div):
                return get_url(div).rsplit('/')[-1]

            def get_url(div):
                return client.get_url(div.find('h2', class_='itemtitle').a['href'])

            def get_desc(div):
                return div.p.get_text(strip=True)

            def get_auth(div):
                return div.find('span', class_='author').a['title']

            def get_date(div):
                str = div.find('span', class_='author').get_text()
                str = str.replace('\n',   ' ')
                str = str.replace(six.u('\xa0'), ' ')
                match = re.search(r'on\s+(\w{3} [0-9]{1,2}, 20[0-9]{2})', str)
                return datetime.datetime.strptime(match.group(1), "%b %d, %Y")

            def get_title(div):
                return div.find('h2', class_='itemtitle').a['title']

            return {
                'id':    get_id(div),
                'url':   get_url(div),
                'desc':  get_desc(div),
                'auth':  get_auth(div),
                'date':  get_date(div),
                'title': get_title(div),
            }

        videos = self.soup.findAll('div', {'class': 'news_type_video'})
        return [create_summary(div) for div in videos]
816467
function() {

            var self = this;
            var summary = 
                self.tableSummaryBuilder(self.groupsSummary,
                                         self.pagesSummary, 
                                         self.total);
            $('#' + self.getId('summary')).html(summary);

        }
1158845
def get_summary(self):
        
        func_summaries = [f.get_summary() for f in self.functions]
        modif_summaries = [f.get_summary() for f in self.modifiers]
        return (self.name, [str(x) for x in self.inheritance], [str(x) for x in self.variables], func_summaries, modif_summaries)
458816
def __get_plots_of_the_current_page(self, section, page):
        """"""
        
        plots = []
        structure = [len(x) for x in self.sections[section].pages[page].layout]
        for key in self.sections[section].pages[page].elements.keys():
            if self.sections[section].pages[page].elements[key].plot_object is None:
                plots.append(None)
            else:
                plots.append(self.sections[section].pages[page].elements[key].name)


        plots_sub = []
        for idx, i in enumerate(list(accumulate(structure))):
            if idx == 0:
                plots_sub.append(plots[0:i])
            else :
                plots_sub.append(plots[list(accumulate(structure))[idx - 1]:i])

        return plots_sub
675053
def download_slides(self):
        
        return self.presentation.client.download_all(self.presentation.metadata['slides'], self.tmp_dir)
597836
def render_summary(self, include_title=True, request=None):
        """"""
        title = ''
        frames = []
        classes = ['traceback']
        if not self.frames:
            classes.append('noframe-traceback')

        if include_title:
            if self.is_syntax_error:
                title = text_('Syntax Error')
            else:
                title = text_('Traceback <small>(most recent call last)'
                              '</small>')

        for frame in self.frames:
            frames.append(
                text_('<li%s>%s') % (
                    frame.info and text_(' title="%s"' % escape(frame.info)) or
                    text_(''),
                    frame.render()
                ))

        if self.is_syntax_error:
            description_wrapper = text_('<pre class=syntaxerror>%s</pre>')
        else:
            description_wrapper = text_('<blockquote>%s</blockquote>')

        vars = {
            'classes': text_(' '.join(classes)),
            'title': title and text_('<h3 class="traceback">%s</h3>'
                                     % title) or text_(''),
            'frames': text_('\n'.join(frames)),
            'description': description_wrapper % escape(self.exception),
        }
        app = request.app
        template = app.ps.jinja2.env.get_template('debugtoolbar/exception_summary.html')
        return template.render(app=app, request=request, **vars)
995488
def GetPageInfo(self):
        

        return self.first_tab, self.last_tab, self.first_tab, self.last_tab
64750
def pages(self):
        
        url = self._build_url('pages', base_url=self._api)
        json = self._json(self._get(url), 200)
        return PagesInfo(json) if json else None
587229
def pages(self):
        
        pages = []
        for har_dict in self.har_data:
            har_parser = HarParser(har_data=har_dict)
            if self.page_id:
                for page in har_parser.pages:
                    if page.page_id == self.page_id:
                        pages.append(page)
            else:
                pages = pages + har_parser.pages
        return pages
516294
def extract_program_summary(data):
    '''
    
    '''
    from bs4 import BeautifulSoup
    soup = BeautifulSoup(data, 'html.parser')
    try:
        return soup.find(
            'div', {'class': 'episode-synopsis'}
        ).find_all('div')[-1].text.strip()
    except Exception:
        _LOGGER.info('No summary found for program: %s',
                     soup.find('a', {'class': 'prog_name'}))
        return "No summary"
1115088
public function renderSummary()
	{
		if(($count=$this->dataProvider->getItemCount())<=0)
			return;

		echo CHtml::openTag($this->summaryTagName, array('class'=>$this->summaryCssClass));
		if($this->enablePagination)
		{
			$pagination=$this->dataProvider->getPagination();
			$total=$this->dataProvider->getTotalItemCount();
			$start=$pagination->currentPage*$pagination->pageSize+1;
			$end=$start+$count-1;
			if($end>$total)
			{
				$end=$total;
				$start=$end-$count+1;
			}
			if(($summaryText=$this->summaryText)===null)
				$summaryText=Yii::t('zii','Displaying {start}-{end} of 1 result.|Displaying {start}-{end} of {count} results.',$total);
			echo strtr($summaryText,array(
				'{start}'=>$start,
				'{end}'=>$end,
				'{count}'=>$total,
				'{page}'=>$pagination->currentPage+1,
				'{pages}'=>$pagination->pageCount,
			));
		}
		else
		{
			if(($summaryText=$this->summaryText)===null)
				$summaryText=Yii::t('zii','Total 1 result.|Total {count} results.',$count);
			echo strtr($summaryText,array(
				'{count}'=>$count,
				'{start}'=>1,
				'{end}'=>$count,
				'{page}'=>1,
				'{pages}'=>1,
			));
		}
		echo CHtml::closeTag($this->summaryTagName);
	}
587975
def __summary(self):
        """"""
        text = "Time: %s\n" % self.when
        text += "Comitter: %s\n" % self.editor

        inst = self.timemachine.presently

        if self.action_type == "dl":
            text += "Deleted %s\n" % inst._object_type_text()
        elif self.action_type == "cr":
            text += "Created %s\n" % inst._object_type_text()
        else:
            text += "Modified %s\n" % inst._object_type_text()
        text += self._details(nohtml=True)
        return text
306779
def contents(self):
        
        data = find_dataset_path(
            self.name, data_home=self.data_home, ext=None
        )
        return os.listdir(data)
277637
def get_summary(self):
        
        if not self.is_valid():
            return None
        else:
            return {
                "source": self.source,
                "assembly": self.assembly,
                "build": self.build,
                "build_detected": self.build_detected,
                "snp_count": self.snp_count,
                "chromosomes": self.chromosomes_summary,
                "sex": self.sex,
            }
646391
def get_summary(self, verb=False, max_columns=100, width=1000):
        
        # Make sure the data is accessible
        msg = "The data is not accessible because self.strip(2) was used !"
        assert self._dstrip['strip']<2, msg

        # Build the list
        d = self._dStruct['dObj']
        data = []
        for k in self._ddef['dStruct']['order']:
            if k not in d.keys():
                continue
            for kk in d[k].keys():
                lu = [k,
                      self._dStruct['dObj'][k][kk]._Id._dall['Name'],
                      self._dStruct['dObj'][k][kk]._Id._dall['SaveName'],
                      self._dStruct['dObj'][k][kk]._dgeom['nP'],
                      self._dStruct['dObj'][k][kk]._dgeom['noccur'],
                      self._dStruct['dObj'][k][kk]._dgeom['mobile'],
                      self._dStruct['dObj'][k][kk]._dmisc['color']]
                for pp in self._dextraprop['lprop']:
                    lu.append(self._dextraprop['d'+pp][k][kk])
                data.append(lu)

        # Build the pandas DataFrame
        col = ['class', 'Name', 'SaveName', 'nP', 'noccur',
               'mobile', 'color'] + self._dextraprop['lprop']
        df = pd.DataFrame(data, columns=col)
        pd.set_option('display.max_columns',max_columns)
        pd.set_option('display.width',width)

        if verb:
            print(df)
        return df
855839
def get_action_list(self, page=1):
        
        kw = {}
        if page:
            kw['inum'] = page
        actions, _ = self._call('getactionlist', **kw)
        result_list = []
        for action in actions:
            result_list.append(ActionInList.object_from_api(action))
        return result_list
593359
public function summaries()
    {
        if (is_null($this->summaryRequests)) {
            $this->summaryRequests = new SummaryRequests($this->client);
        }

        return $this->summaryRequests;
    }