Return the list of book names
14980
def list_books(self):
        '''  '''
        names = []
        try:
            for n in self.cur.execute("SELECT name FROM book;").fetchall():
                names.extend(n)
        except:
            self.error("ERROR: cannot find database table 'book'")
        return(names)
274942
def get_books(self):
        """"""
        # Implemented from kitosid template for -
        # osid.resource.BinLookupSession.get_bins_template
        catalogs = self._get_provider_session('book_lookup_session').get_books()
        cat_list = []
        for cat in catalogs:
            cat_list.append(Book(self._provider_manager, cat, self._runtime, self._proxy))
        return BookList(cat_list)
247767
def rpc_get_names(self, filename, source, offset):
        """"""
        names = jedi.api.names(source=source,
                               path=filename, encoding='utf-8',
                               all_scopes=True,
                               definitions=True,
                               references=True)

        result = []
        for name in names:
            if name.module_path == filename:
                offset = linecol_to_pos(source, name.line, name.column)
            elif name.module_path is not None:
                with open(name.module_path) as f:
                    text = f.read()
                offset = linecol_to_pos(text, name.line, name.column)
            result.append({"name": name.name,
                           "filename": name.module_path,
                           "offset": offset})
        return result
469121
def as_list(self):
        """"""
        go_id = self.go_term.id
        
        qual_str = '|'.join(self.qualifier)
        db_ref_str = '|'.join(self.db_ref)
        taxon_str = '|'.join(self.taxon)

        # with_from is currently left as a string
        # with_from = '|'.join()
        with_from_str = self.with_from or ''
        db_name_str = self.db_name or ''
        db_syn_str = '|'.join(self.db_syn)
        ext_str = '|'.join(self.ext)
        product_id_str = self.product_id or ''

        l = [
            self.db,
            self.db_id,
            self.db_symbol,
            qual_str,
            go_id,
            db_ref_str,
            self.ev_code,
            with_from_str,
            self.aspect,
            db_name_str,
            db_syn_str,
            self.db_type,
            taxon_str,
            self.date,
            self.assigned_by,
            ext_str,
            product_id_str,
        ]
        return l
1294872
def get_books(self):
        
        return itunespy.lookup(id=self.artist_id, entity=itunespy.entities['ebook'])[1:]
326265
def get_book_currencies(self) -> List[Commodity]:
        
        query = (
            self.currencies_query
                .order_by(Commodity.mnemonic)
        )
        return query.all()
180451
def pull(self,bookName=None,sheetName=None):
        """"""

        # tons of validation
        if bookName is None and self.bookName: bookName=self.bookName
        if sheetName is None and self.sheetName: sheetName=self.sheetName
        if bookName is None: bookName=OR.activeBook()
        if bookName and sheetName is None: sheetName=OR.activeSheet()
        if not bookName or not sheetName:
            print("can't figure out where to pull from! [%s]%s"%(bookName,sheetName))
            return

        # finally doing the thing
        poSheet=OR.getSheet(bookName,sheetName)
        self.bookName=bookName
        self.sheetName=sheetName
        self.desc=poSheet.GetLongName()
        self.colNames=[poCol.GetName() for poCol in poSheet.Columns()]
        self.colDesc=[poCol.GetLongName() for poCol in poSheet.Columns()]
        self.colUnits=[poCol.GetUnits() for poCol in poSheet.Columns()]
        self.colComments=[poCol.GetComments() for poCol in poSheet.Columns()]
        self.colTypes=[poCol.GetType() for poCol in poSheet.Columns()]
        self.colData=[poCol.GetData() for poCol in poSheet.Columns()]
141951
def extract_books
      booklist = []
      if @doc.count != 0
        @doc.each do |book_data|
          book = {}
          book['title'] = book_data['titleMain']
          book['book_url'] = BOOK_URL + book_data['prodId']
          book['crt_time'] = book_data['crtTime'].split(' ')[0]
          booklist << book
        end
      end
      booklist
    end
603906
def libraries():
    """"""
    ls = libraries_dir().dirs()
    ls = [str(x.name) for x in ls]
    ls.sort()
    return ls
222770
def bib_keys(self):
        """"""
        bib_keys = []
        # Get bib keys in this document
        for match in texutils.cite_pattern.finditer(self.text):
            keys = match.group(5).split(',')
            bib_keys += keys

        # Recursion
        for path, document in self._children.iteritems():
            bib_keys += document.bib_keys
        bib_keys = list(set(bib_keys))

        return bib_keys
237438
def get_publications():
    
    data = DOWNER.download(URL)
    dom = dhtmlparser.parseString(data)

    book_list = dom.find("div", {"class": "seznamKniha"})

    assert book_list, "Can't find <div> with class 'seznamKniha'!"

    books = []
    for html_chunk in book_list:
        a = html_chunk.find("a")

        assert a, "Can't find link to the details of the book!"

        if a[0].find("span", {"class": "ruzek pripravujeme"}):
            continue

        books.append(
            _process_book(a[0].params["href"])
        )

    return books
1215033
def list_():
    '''
    
    '''
    cmd = 'pkgutil --pkgs'
    ret = salt.utils.mac_utils.execute_return_result(cmd)
    return ret.splitlines()
245159
def get_publications():
    
    books = []
    for link in get_book_links(LINKS):
        books.append(
            _process_book(link)
        )

    return books
584872
def get_published_list(
        self, search='', start=0, limit=0, order_by='', order_by_dir='ASC'
    ):
        
        return self.get_list(
            search=search,
            start=start,
            limit=limit,
            order_by=order_by,
            order_by_dir=order_by_dir,
            published_only=True
        )
1076945
def get(self, force=False) -> 'List[Titles]':
        
        try:
            if force:
                raise CacheMissingError
            return self._cache.load()
        except CacheMissingError:
            titles = self._requester()
            self._cache.save(titles)
            return titles
1328274
private static List<Tuple2<Book,ReadableInstant>> getSitemapBooks(
		final ServletContext servletContext,
		HttpServletRequest req,
		HttpServletResponse resp
	) throws ServletException, IOException {
		SemanticCMS semanticCMS = SemanticCMS.getInstance(servletContext);
		HtmlRenderer htmlRenderer = HtmlRenderer.getInstance(servletContext);
		final SortedSet<View> views = htmlRenderer.getViews();
		List<Book> books;
		{
			// Filter published and accessible only
			Collection<Book> values = semanticCMS.getPublishedBooks().values();
			books = new ArrayList<>(values.size());
			for(Book book : values) if(book.isAccessible()) books.add(book);
		}
		int numBooks = books.size();
		if(
			numBooks > 1
			&& CountConcurrencyFilter.useConcurrentSubrequests(req)
		) {
			// Concurrent implementation
			final HttpServletRequest threadSafeReq = new UnmodifiableCopyHttpServletRequest(req);
			final HttpServletResponse threadSafeResp = new UnmodifiableCopyHttpServletResponse(resp);
			final TempFileContext tempFileContext = ServletTempFileContext.getTempFileContext(req);
			List<Book> booksWithSiteMapUrl;
			{
				List<Callable<Boolean>> tasks = new ArrayList<>(numBooks);
				{
					for(final Book book : books) {
						tasks.add(
							new Callable<Boolean>() {
								@Override
								public Boolean call() throws ServletException, IOException {
									HttpServletRequest subrequest = new HttpServletSubRequest(threadSafeReq);
									HttpServletResponse subresponse = new HttpServletSubResponse(threadSafeResp, tempFileContext);
									if(logger.isLoggable(Level.FINE)) logger.log(
										Level.FINE,
										"called, subrequest={0}, book={1}",
										new Object[] {
											subrequest,
											book
										}
									);
									return hasSiteMapUrl(
										servletContext,
										subrequest,
										subresponse,
										views,
										book,
										book.getContentRoot()
										//new HashSet<PageRef>()
									);
								}
							}
						);
					}
				}
				List<Boolean> results;
				try {
					results = semanticCMS.getExecutors().getPerProcessor().callAll(tasks);
				} catch(InterruptedException e) {
					throw new ServletException(e);
				} catch(ExecutionException e) {
					Throwable cause = e.getCause();
					if(cause instanceof RuntimeException) throw (RuntimeException)cause;
					if(cause instanceof ServletException) throw (ServletException)cause;
					if(cause instanceof IOException) throw (IOException)cause;
					throw new ServletException(cause);
				}
				// Now find the last modified with concurrency
				booksWithSiteMapUrl = new ArrayList<>(numBooks);
				{
					int i = 0;
					for(Book book : books) {
						if(results.get(i++)) booksWithSiteMapUrl.add(book);
					}
					assert i == numBooks;
				}
			}
			int booksWithSiteMapUrlSize = booksWithSiteMapUrl.size();
			if(booksWithSiteMapUrlSize > 0) {
				if(booksWithSiteMapUrlSize > 1) {
					// Concurrent implementation
					List<Callable<ReadableInstant>> lastModifiedTasks = new ArrayList<>(booksWithSiteMapUrlSize);
					{
						for(final Book book : booksWithSiteMapUrl) {
							lastModifiedTasks.add(
								new Callable<ReadableInstant>() {
									@Override
									public ReadableInstant call() throws ServletException, IOException {
										HttpServletRequest subrequest = new HttpServletSubRequest(threadSafeReq);
										HttpServletResponse subresponse = new HttpServletSubResponse(threadSafeResp, tempFileContext);
										if(logger.isLoggable(Level.FINE)) logger.log(
											Level.FINE,
											"called, subrequest={0}, book={1}",
											new Object[] {
												subrequest,
												book
											}
										);
										return SiteMapServlet.getLastModified(
											servletContext,
											subrequest,
											subresponse,
											views,
											book
										);
									}
								}
							);
						}
					}
					List<ReadableInstant> lastModifieds;
					try {
						lastModifieds = semanticCMS.getExecutors().getPerProcessor().callAll(lastModifiedTasks);
					} catch(InterruptedException e) {
						throw new ServletException(e);
					} catch(ExecutionException e) {
						Throwable cause = e.getCause();
						if(cause instanceof RuntimeException) throw (RuntimeException)cause;
						if(cause instanceof ServletException) throw (ServletException)cause;
						if(cause instanceof IOException) throw (IOException)cause;
						throw new ServletException(cause);
					}
					List<Tuple2<Book,ReadableInstant>> sitemapBooks = new ArrayList<>(booksWithSiteMapUrlSize);
					for(int i = 0; i < booksWithSiteMapUrlSize; i++) {
						sitemapBooks.add(
							new Tuple2<>(
								booksWithSiteMapUrl.get(i),
								lastModifieds.get(i)
							)
						);
					}
					return sitemapBooks;
				} else {
					// Single implementation
					Book book = booksWithSiteMapUrl.get(0);
					return Collections.singletonList(
						new Tuple2<>(
							book,
							SiteMapServlet.getLastModified(
								servletContext,
								req,
								resp,
								views,
								book
							)
						)
					);
				}
			} else {
				return Collections.emptyList();
			}
		} else {
			// Sequential implementation
			List<Tuple2<Book,ReadableInstant>> sitemapBooks = new ArrayList<>(numBooks);
			for(Book book : books) {
				if(
					hasSiteMapUrl(
						servletContext,
						req,
						resp,
						views,
						book,
						book.getContentRoot()
					)
				) {
					sitemapBooks.add(
						new Tuple2<>(
							book,
							SiteMapServlet.getLastModified(
								servletContext,
								req,
								resp,
								views,
								book
							)
						)
					);
				}
			}
			return sitemapBooks;
		}
	}
896755
def list(self):
        """"""
        return [x["_id"] for x in self._db.system.js.find(projection=["_id"])]