def create(username): index = r.hgetall(SESSION_PREFIX + username) # 检查库存 for k, v in index.items(): stock = Book.get_stock(k) if int(stock) < int(v): return False r.rename(SESSION_PREFIX + username, ORDER_PREFIX + username) for k, v in index.items(): stock = Book.get_stock(k) Book.set_stock(k, int(stock) - int(v)) db.orders.insert({'username': username, 'books': index}) return True
def by_title(self, title): """ Search for a book on OpenLibrary by title @param title: the title to search for @return: the raw data of all results """ title = title.replace(' ', '+').lower() url = urllib.request.urlopen(self.search_url+'title='+title) data = simplejson.load(url)['docs'] for result in data: book = Book(0) book.title = result['title'] try: book.authors = ', '.join(result['author_name']) if isinstance(result['publisher'], list) else result['author_name'] except KeyError: book.authors = "None" try: book.publisher = ', '.join(result['publisher']) if isinstance(result['publisher'], list) else result['publisher'] except KeyError: book.publisher = "No publisher found." try: book.publ_year = result['first_publish_year'] except KeyError: book.publ_year = 0 try: book.description = ''.join(result['first_sentence']) except KeyError: book.description = "No description found." yield book
def delete_book(): to_do = input('''We're going to delete a book. Do you have the barcode? [y/N]: ''') if to_do.strip() == "" or to_do.strip().lower() == "n": results = search() i = 1 for item in results: print((i + ") " + item)) # not sure how this will come out. del_me = input("Which one is it? ") del_me = int(del_me) del_me = results[del_me - 1] del_me = del_me.split(",") del_me = Book(del_me[0]) # this is really fudged atm. serious testing needed the_db = Bdb(dbLocation) the_db.delete(del_me) print("Deleted.") elif to_do.strip().lower() == "y": del_me = input("Ok, enter it now: ") if del_me.strip() == "": print("Invalid input.") else: del_me = int(del_me) del_me = Book(del_me) the_db = Bdb(dbLocation) the_db.delete(del_me) print("Deleted.")
def test_decrease_number_of_copies(self): book = Book("Lords", "Steven Moore", 2000, "Thriller", 2, 15) book.decrease_number_of_copies(10) self.assertEqual(5, book.number_of_copies) book.decrease_number_of_copies(6) self.assertNotEqual(-1, book.number_of_copies) self.assertEqual(0, book.number_of_copies)
class Tractatus: # This is the book tractatus = None def __init__(self): """ Construct the Tractatus """ # Build the Book object self.tractatus = Book() # Get the tractatus from text SITE_ROOT = os.path.realpath(os.path.dirname(__file__)) all_text = open(os.path.join(SITE_ROOT, "static", "tractatus.txt"), 'r') output = all_text.readlines() # Read the file line by line into self.tractatus # The actual content only begins at line 30 until the end for i in range(30, len(output)): complete_string = str(output[i]) # We need to separate the index and the text split_string = complete_string.partition(" ") index = split_string[0] text = split_string[2].rstrip("\n") # Load them in self.tractatus.add_section(index, text) # print self.tractatus def get_book(self): return self.tractatus
def test_increase_number_of_copies(self): book = Book("Lords", "Steven Moore", 2000, "Thriller", 2, 0) book.increase_number_of_copies(10) self.assertEqual(10, book.number_of_copies) book.increase_number_of_copies(5) self.assertNotEqual(10, book.number_of_copies) self.assertEqual(15, book.number_of_copies)
def test_read_book(): book = Book('test/test_text_file.txt') book.read_book() chapters = book.get_chapters assert len(chapters) == 2 assert chapters[0].get('title') == 'Chapter 1' sentences = chapters[0].get('sentences') assert len(sentences) == 4
def add_book(self, b_name, b_quantity): b = Book(name= b_name, quantity= int(b_quantity)) urllib.unquote(b.name) self.response.write("> Voce cadastrou o livro: " + b.name + " com "+ str(b.quantity)) b.put()
def parse_all_books(): for file in glob.glob("{}/*.txt".format(book_dir)): print("Parsing... {}".format(file)) book = Book(file) book.read_book() book.count_distinct_words() print(book) all_books.append(book)
def delete(self, conn): for row in self.select(conn): book = Book( row['id'], row['title'], None, row['published_in'], ) book.delete(conn) print("")
def read_book(self, bookname, read_what=None): if self.suffix == "": print bookname filename = self.dir + "/" + bookname else: print bookname + "." + self.suffix filename = self.dir + "/" + bookname + "." + self.suffix book = Book(filename) self.books.append(book) self.current_monad = book.read_linear(self.current_monad) + 1
def update_location(id): book = Book(id) if 'update_person' in request.form: new_location = request.form['location'] else: new_location = request.form['shelf'] book.update_location(new_location) return render_book_info(book)
def run(): mbook = Book.parse(get_mtgox()) bbook = Book.parse(bitfloor.book(level=2)) mbook.flatten('0.01') our_book, our_book2 = get_our_book() # remove our stuff from bbook # bbook will have the orders we don't control bbook.subtract(our_book2) # mbook will now have the gap needed to be filled by our orders mbook.subtract(bbook) funds = get_funds() # get the total remaining area needed to fill # find which factor of it we can fill with our total funds sumb = sum(o.price*o.size for o in mbook.bids if o.size > 0)*D('1.04') bfactor = min(1, funds['USD']/sumb) if sumb > 0 else 1 suma = sum(o.size for o in mbook.asks if o.size > 0) afactor = min(1, funds['BTC']/suma) if suma > 0 else 1 print afactor, bfactor print suma, sumb # multiply everything positive by the factor # mbook will now have what we need to provide to bitfloor's book for o in mbook.bids: if o.size > 0: o.size *= bfactor o.size = o.size.quantize(D('0.00000001'), rounding=decimal.ROUND_DOWN) for o in mbook.asks: if o.size > 0: o.size *= afactor o.size = o.size.quantize(D('0.00000001'), rounding=decimal.ROUND_DOWN) # now, get the difference between what we need to provide and what we have mbook.subtract(our_book2) # cancel orders first which are above the gap cancel(mbook, our_book, 'bid') cancel(mbook, our_book, 'ask') # send in orders to fill the gaps for o in mbook.bids: if o.size > SIZE_LIMIT: print 'bid', o bitfloor.buy(size=str(o.size), price=str(o.price)) for o in mbook.asks: if o.size > SIZE_LIMIT: print 'ask', o bitfloor.sell(size=str(o.size), price=str(o.price))
def _make_book(self, cell, year): bookID, title, originalTitle = self._extract_titles(cell) book = Book(bookID, title, originalTitle, year) alt = filter(alt_text, cell) if alt: assert len(alt) == 1 #noinspection PyUnresolvedReferences book.addTitles(*[x.strip() for x in re.split('\s*;\s+', alt[0].text.strip()[3:-1])]) return book
def update(self, conn, field, new_value): for row in self.select(conn): author_name = Authors(['name', '=', row[2]]).select(conn).fetchone()[1] if field == "name": author_name = new_value book = Book( row['id'], row['title'], author_name, row['published_in'], ) setattr(book, field, new_value) book.save(conn)
def process_json(json_request): books = json_request['Books'] book_id_list = [] for book in books: user_book_dict[book[u'ID']] = Book(book[u'ID'], book[u'Title'], book[u'Description'], book[u'Image'], book[u'isbn']) if u'Subtitle' in book: user_book_dict[book[u'ID']].subtitle = book[u'Subtitle'] book_id_list.append(book[u'ID']) return book_id_list
def create_book_from_dict(book_dict): book = Book(book_dict["bc"], book_dict["isbn"], book_dict["title"], book_dict["authors"], book_dict["pages"], book_dict["publ_year"], book_dict["publisher"], book_dict["location"], book_dict["description"], book_dict["call_num"], book_dict["tags"]) return book
def uploadtextbook(): if session.get('user') is not None: username = decode(session['user']).userid email = decode(session['user']).email else: username = None email = None return redirect(url_for('login')) error = None if request.method == 'POST': title = request.form['title'] author = request.form['author'] subject = request.form['subject'] course = request.form['course'] condition = request.form['condition'] price = request.form['price'] boolError = isValidUpload(title, author, subject, course, condition, price) if boolError[0]: app.logger.debug('valid upload info') book = Book(title, author, subject, course, condition, price, username, email) dao = BookDao() dao.insert(book) return findtextbooks() else: error = boolError[1] app.logger.debug('error %r', error) return render_template('uploadtextbook.html', **locals())
def get_our_book(): orders = bitfloor.orders() our_book = { 'bids': {}, 'asks': {} } our_book2 = { 'bids': [], 'asks': [] } for o in orders: size = Decimal(str(o['size'])) price = Decimal(str(o['price'])) order = Order(size, price) order.id = o['order_id'] # TODO: hacky tup = (str(price), str(size)) if o['side'] == 0: our_book['bids'].setdefault(price, []).append(order) our_book2['bids'].append(tup) elif o['side'] == 1: our_book['asks'].setdefault(price, []).append(order) our_book2['asks'].append(tup) return our_book, Book.parse(our_book2)
def reading_file(name, books, libraries): #print("Reading file") mon_fichier = open(name, "r") content = mon_fichier.readlines() nb_books = content[0].split(" ")[0] nb_libraries = content[0].split(" ")[1] nb_days_scanning = content[0].split(" ")[2] for idx, livre in enumerate(content[1].split(" ")): new_book = Book(idx, int(livre)) books.append(new_book) for idx, library in enumerate(content[2:]): if len(library) > 2: #print(idx, library) if idx % 2 == 0: new_library = Library(int(idx / 2), [], int(library.split(" ")[1]), int(library.split(" ")[2])) libraries.append(new_library) else: libraries[-1].books = [] temp_list_livres = library.split(" ") for num in temp_list_livres: num = int(num) libraries[-1].books.append(books[num]) #time.sleep(0.01) mon_fichier.close() return int(nb_days_scanning)
def get_books(self, query=None, genre=None, year=None, p=None): books = [] offset = (int(p) - 1) * 12 if (int(p) > 0 and p) else 0 with dbapi2.connect(self.db_url) as connection: cursor = connection.cursor() if query: query1 = "SELECT ID, TITLE, YR, COVER FROM BOOK WHERE LOWER(TITLE) LIKE LOWER(%s) ORDER BY ID OFFSET %s LIMIT 12" query_words = query.split() like_pattern = '%' for word in query_words: like_pattern += '{}%'.format(word) cursor.execute(query1, (like_pattern, offset)) elif genre: query1 = "SELECT BOOK.ID, BOOK.TITLE, BOOK.YR, BOOK.COVER FROM BOOK INNER JOIN GENRES ON BOOK.ID = GENRES.BOOKID WHERE (GENRE = %s) GROUP BY BOOK.ID, BOOK.TITLE, BOOK.YR, BOOK.COVER ORDER BY BOOK.ID OFFSET %s LIMIT 12" cursor.execute(query1, (genre, offset)) elif year: query1 = "SELECT ID, TITLE, YR, COVER FROM BOOK WHERE (YR = %s) ORDER BY ID OFFSET %s LIMIT 12" cursor.execute(query1, (year, offset)) else: query1 = "SELECT ID, TITLE, YR, COVER FROM BOOK ORDER BY ID OFFSET %s LIMIT 12" cursor.execute(query1, (offset, )) for book_id, title, year, cover in cursor: books.append( Book(id=book_id, title=title, year=year, cover=cover)) return books
def create_book_list(): book_list = [] for i in range(0, 10): book_list.append(Book()) with open('resources/book_list', 'wb') as fp: pickle.dump(book_list, fp)
class BookTest(unittest.TestCase): mozzarella = Recipe('mozzarella_sticks', 3, 20, ['mozzarella', 'sticks'], "", "starter") nugget = Recipe('nugget', 4, 65, ['chicken', 'bread'], "", "starter") omelette = Recipe('omelette au fromage', 2, 10, ['eggs', 'cheese', 'pepper'], "", "lunch") fondant = Recipe('fondant', 4, 30, ['eggs', 'chocolate', 'butter'], "", "dessert") creation = datetime.datetime(2019, 4, 13, 00, 00, 00) last = datetime.datetime(2019, 5, 27, 00, 00, 00) recipe_list = { 'starter': { mozzarella, nugget, }, 'lunch': { omelette, }, 'dessert': { fondant, } } test_book = Book("Text Book", last, creation, recipe_list) def test_get_recipe_by_type_method(self): gibberish_type = "blabla" integer_type = 123 with self.assertRaises(SystemExit): self.test_book.get_recipes_by_type(gibberish_type) self.test_book.get_recipes_by_type(integer_type) def test_get_recipe_by_name_method(self): non_existing_name = "blabla" int_name = 123 empty_name = "" with self.assertRaises(SystemExit): self.test_book.get_recipes_by_type(non_existing_name) self.test_book.get_recipes_by_type(int_name) self.test_book.get_recipes_by_type(empty_name) def test_add_recipe_method(self): non_recipe_object = "blabla" with self.assertRaises(SystemExit): self.test_book.add_recipe(non_recipe_object) def test_add_recipe_does_the_adding(self): recipe_to_add = Recipe('pasta', 1, 9, ['pasta', 'water'], "", 'lunch') self.test_book.add_recipe(recipe_to_add) type_of_added_recipe = recipe_to_add.recipe_type self.assertIn(recipe_to_add, self.test_book.recipes_list[type_of_added_recipe]) def test_add_recipe_method_update_time(self): recipe_to_add = Recipe('cheesecake', 5, 45, ['cheese', 'cake'], "", 'dessert') last_update1 = self.test_book.last_update self.test_book.add_recipe(recipe_to_add) self.test_book.print_content_recipe_list() last_update2 = self.test_book.last_update self.assertNotEqual(last_update1, last_update2)
def create_item(): """ Creates an item. :return: an item """ print( "What kind of items would you like to add to the library catalogue?" ) print("1. Book") print("2. DVD") print("3. Journal") option = int(input("Select type of item: ")) title = input("Enter title: ") call_num = input("Enter call number: ") author = input("Enter author name: ") num_copies = input("Enter the number of copies: ") if option == 1: return Book(call_num, title, num_copies, author) if option == 2: release_date = input("Enter release date: ") region_code = input("Enter region code: ") return Dvd(call_num, title, num_copies, author, release_date, region_code) if option == 3: names = input("Enter name: ") issue_number = input("Enter issue number: ") publisher = input("Enter publisher: ") return Journal(call_num, title, num_copies, author, names, issue_number, publisher)
def get_book(file_path): xmldoc = minidom.parse(file_path) itemlist = xmldoc.getElementsByTagName('section') book_name = xmldoc.getElementsByTagName( 'book-title')[0].firstChild.nodeValue logging.info('Book name is:' + book_name) text = get_text(itemlist) words = text.split() count_p = xmldoc.getElementsByTagName('p').length count_words = len(words) count_letters = len(text) words_with_capital_letter = 0 words_without_capital_letter = 0 for word in words: if word.istitle(): words_with_capital_letter += 1 else: words_without_capital_letter += 1 return Book(book_name, count_p, count_words, count_letters, words_with_capital_letter, words_without_capital_letter) logging.info('Count of words in lowercase is: ' + str(words_without_capital_letter)) logging.info('Count of words with capital letter is:' + str(words_with_capital_letter))
def register_book(self): system('cls') ISBN = input("Enter the ISB of book: ") pos = self.find_ISBN(ISBN) if pos == -1: title = input("Enter the title of book: ") author = input("Enter the author of book: ") pages = int(input("Enter the pages of book: ")) edition = input("Enter the edition of book: ") publisher = input("Enter the publisher of book: ") place = input("Enter the place of book: ") date_edition = self.__order_date_book() new_book = Book(title, author, ISBN, pages, edition, publisher, place, date_edition) self.books.append(new_book) system('cls') print("The book was save successful !!") else: print("ERROR - The book already exists") input()
def addBook(self, author, country, imageLink, language, link, pages, title, year): """ books리스트에 Book클래스로 추가하고 bookset.json에 추가로 저장할것 :param author: :param country: :param imageLink: :param language: :param link: :param pages: :param title: :param year: :return: """ self.books.append(Book(author, country, imageLink, language, link, pages, title, year)) json_data = [] obj = {"author": author, "country": country, "imageLink": imageLink, "language": language, "link": link, "pages": pages, "title": title, "year": year} with open('bookset.json') as f: json_data = json.load(f) json_data.append(obj) with open('bookset.json', 'w') as f: json.dump(json_data, f) print(f'성공적으로 책제목: {obj["title"]}을 저장하였습니다.')
def makeBook(**params): name = params['name'] extraData = params['extraData'] author = params['author'] public = params['public'] content = params['content'] img_url = params['img_url'] db_num = params['db_num'] card = Card() card.set('name', name) card.set('author', author) card.set('content', content) card.set('img_url', img_url) card.set('extraData', json.loads(extraData)) card.set('db_num', db_num) if 'formId' in params: formId = params['formId'] card.set('formId', formId) userid = params['userid'] user = User.create_without_data(userid) card.set('user', user) card.set('user', user) card.set('type', 'book') card.set('public', public) card.set('publish', False) card.set('likes', 0) card.set('shares', 0) card.save() stat = Book.generate(card) if stat == 'ok': result = {'code': 200, 'data': card.get('objectId')} return result else: result = {'code': 500, 'message': 'failed'} return result
def api_update_book(id): data = Library.str_to_json(flask.request.json) library = load_library() book = library.get_book(id) if not book: flask.abort(404) if not data or not valid_post_put(data, post=False): flask.abort(400) old_book_data = book.to_dict() updated_book = Book( id, **dict( (k, data.get(k, old_book_data[k])) for k in Book.DEFAULTS.keys())) library.update_book(id, updated_book) library.save() return flask.jsonify({'book': updated_book.to_dict()})
def parse_input(file): B = 0 L = 0 D = 0 libraries = [] books = [] with open("input/" + file, "r") as input: lines = input.readlines() [B, L, D] = [int(i) for i in lines[0].split(" ")] book_scores = [int(i) for i in lines[1].split(" ")] for idx, score in enumerate(book_scores): books.append(Book(score, idx)) lines = lines[2:] for idx, line in enumerate(lines): if line == "\n": break if idx % 2 == 0: libraries.append( Library(lines[idx], lines[idx + 1], idx // 2, books)) return Problem(B, L, D, books, libraries)
def fare(): try: if request.method == "GET": ''' jwt_token = request.headers["token"] stat, tok = Authorize.verify_jwt(jwt_token) if stat == 0: raise ValueError("Not authorized") if len(tok) > 0: logging.critical("failure in v1/fare with token expired: ") return token_expiry_error ''' user_number = request.args["number"] from_latitude = request.args["fromLatitude"] from_longitude = request.args["fromLongitude"] to_latitude = request.args["toLatitude"] to_longitude = request.args["toLongitude"] response = Book.get_fare(from_longitude, from_latitude, to_longitude, to_latitude) response = json.dumps(response) with app.app_context(): response = make_response(response) return response except RuntimeError as e: logging.critical("failure in v1/fare with error: " + str(e)) return default_error
def add_book(self, book = Book()): """ This method appends a book to the booklists :param book: book is an instance of the Class "Book" :return: None """ self.booklists.append(book)
def adding_book(self, this_author, appInfo): if self.lineEdit_4.text(): if self.lineEdit.text(): book = self.lineEdit_4.text() self.lineEdit_4.setText("") if book not in this_author.book_list: this_author.book_list.append(book) this_book = Book(book, self.lineEdit.text()) if this_book not in appInfo.library.book_list: appInfo.library.add_book_object(this_book) appInfo.books_database.insert_one({ "name": this_book.name, "author": this_book.author, "year": this_book.year, "description": this_book.description, "tags": this_book.tag_list, "genres": this_book.genre_list }) message = CreateABook(appInfo, this_book) message.exec_() else: message = ErrorDialog() message.label_2.setText("Enter a name first.") message.exec_() self.update_tables(this_author)
def test_constructor_vacio(self): book = Book() self.assertDictEqual(book.__dict__, { '_name': '', '_authorName': '', '_memberLegajo': '' })
def generate_item(call_num): user_input = None # If entered invalid option, loops user back to choices below while user_input != 4: print("What type of item would you like to add") print("1. Book") print("2. DVD") print("3. Journal") print("4. Back") string_input = input("Please enter your choice (1-4)") user_input = int(string_input) title = input("Enter title: ") num_copies = int(input("Enter number of copies (positive number): ")) item_data = (call_num, title, num_copies) # creates the item object of input choice if user_input == 1: author = input("Enter Author Name: ") return Book(item_data[0], item_data[1], item_data[2], author) if user_input == 2: release_date = input("Enter release date (yyyy/mm/dd): ") code = input("Enter region code: ") return DVD(item_data[0], item_data[1], item_data[2], release_date, code) if user_input == 3: names = input("Enter names") issue_number = input("Please enter issue number") publisher = input("Enter publisher") return Journal(item_data[0], item_data[1], item_data[2], names, issue_number, publisher) # return to menu if user_input == 4: pass
def get_new_book_info(): ''' Get title and author of new book from user ''' title = input('Enter title: ') author = input('Enter author: ') return Book(title, author)
def get_book(self, book_id): with dbapi2.connect(self.db_url) as connection: cursor = connection.cursor() query1 = "SELECT TITLE, AUTHORID, YR, PGNUM, COVER, DESCRIPTION FROM BOOK WHERE (ID = %s)" cursor.execute(query1, (book_id, )) title, author_id, year, pageNumber, cover, description = cursor.fetchone( ) author = None if author_id: query2 = "SELECT NAME FROM AUTHOR WHERE (ID = %s)" cursor.execute(query2, (author_id, )) author = cursor.fetchone()[0] query3 = "SELECT AVG(SCORE) FROM REVIEW WHERE (BOOKID = %s)" cursor.execute(query3, (book_id, )) avgscore = cursor.fetchone()[0] genres = self.get_genres(book_id) book_ = Book(id=book_id, title=title, author=author, year=year, genres=genres, pageNumber=pageNumber, cover=cover, description=description, avgscore=avgscore) return book_, author_id
def get_books(**kwargs): ''' Return books from DB. With no arguments, returns everything. ''' sql = None books = [] if kwargs == None: sql = 'SELECT * FROM {}'.format(BOOK_TABLE) if kwargs['read'] == True: sql = 'SELECT * FROM {} WHERE {} = 1'.format(BOOK_TABLE, READ) if kwargs['read'] == False: sql = 'SELECT * FROM {} WHERE {} = 0'.format(BOOK_TABLE, READ) if sql: conn = sqlite3.connect(DB_NAME) conn.row_factory = sqlite3.Row # This type of row can be accessed by column name cur = conn.cursor() rows = cur.execute(sql) for row in rows: read_bool = tf_val(row[3]) book = Book(row[TITLE], row[AUTHOR], read_bool, row[ID]) books.append(book) conn.close() return books
def insert_book(self): if (not self.title_input.text or not self.author_input.text or not self.length_input.text): self.parent.book_list_panel.status_bar_text = \ 'All fields must be completed!' return try: length = int(self.length_input.text) except Exception as e: print(e) self.parent.book_list_panel.status_bar_text = \ 'Please enter a valid number!' return if length <= 0: self.parent.book_list_panel.status_bar_text = \ 'Pages must be a positive integer!' return book = Book(self.title_input.text, self.author_input.text, length, False) self.parent.book_list_panel.book_list.add(book) self.parent.book_list_panel.book_list.save() self.parent.book_list_panel.refresh_books(False) self.parent.book_list_panel.status_bar_text = \ 'Book added successfully!'
def findBook(self, title): for b in self.books: for t in filter(None, chain([b.title], b.alternative)): if Book.compareTitle(t, title): return b return None
def make_book_list(string_from_file): """ turn the string from the file into a list of Book objects""" global book_list if len(string_from_file) > 0: book_json = json.loads(string_from_file) for book in book_json: if 'stars_str' in book: stars_str = book["stars_str"] else: stars_str = "" if 'date' in book: date = book["date"] else: date = "" book_list.append( Book(title=book["title"], author=book["author"], read=bool(book["read"]), id=int(book["id"]), date=date, stars=int(book["stars"]), stars_str=stars_str))
def bookFromUrl(url): try: # Request data from CEO Library # set headers headers = { "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/84.0.4147.89 Safari/537.36" } req = requests.get(url, headers=headers) req.raise_for_status() soup = bs4.BeautifulSoup(req.text, "html.parser") # get cover cover_url = getCoverUrl(soup, 'book-cover-actions') # get title title = getTitle(soup, "book-info-intro") # get authors authors = getAuthors(soup, "book-info-intro") # get isbn and rating #isbn, rating = getISBNRating(soup, "buy-book") #rating = goodReadsSearchForBookRating(title, authors[0]) info = getInfo(soup, "amazon-book-description") book = Book(title, authors, info, cover_url, "NA", 0) return book except Exception as e: print(e)
def __init__(self, conn_details, status_light): """Setup a connection to MPD to be able to play audio. Also update the MPD database with any new MP3 files that may have been added and clear any existing playlists. """ self.status_light = status_light self.book = Book() self.mpd_client = LockableMPDClient() with self.mpd_client: self.mpd_client.connect(**conn_details) self.mpd_client.update() self.mpd_client.clear() self.mpd_client.setvol(100)
def read_input_file(filename: str) -> File: """Reads the data of input problem returns: D: number of days, LIBS: list of Library objects, BOOKS: list of Book objects, """ lines = list( map(lambda x: [int(y) for y in x.strip().split()], open(filename).readlines())) book_count, libs_count, days = lines[0] books = [] for idx, score in enumerate(lines[1]): books.append(Book(idx, score)) assert len(books) == len(lines[1]) libraries = [] for i in range(2, len(lines), 2): if len(lines[i]) == 0: continue num_books, signup_delay, books_per_day = lines[i] lib_books = list(map(lambda x: books[x], lines[i + 1])) assert len(lib_books) == num_books, f"Incorrect parsing of {line[i]}" libraries.append( Library((i - 2) // 2, signup_delay, lib_books, books_per_day)) return File(books, libraries, days)
def pull_book_json(self, book_number): with open(self.file_name, "r") as read_file: data = json.load(read_file) data = data[self.name][str(book_number)] loaded_book = Book(len(data['page']) - 5, book_number) for idi, i in enumerate(data['page']): loaded_book.content[idi].data = eval(i) loaded_book.book_indirection_flag = data['i_flag'] loaded_book.tps = data['tps'] for i in range(512): if loaded_book.content[1].read_no_index_check(i) != 0: for page in loaded_book.content: page.num_records += 1 return loaded_book
def list_req(self): """ This function is to giving information about the required books and it will be displayed as button on the BoxLayout :return: none """ self.root.ids.box_display.clear_widgets() for each in self.data_list.printed_the_books("r"): temp_book = Book(each) temp_click = Button(text=each[0]) temp_click.bind(on_release=self.mark_as_completed) temp_click.background_color = temp_book.get_the_color() self.root.ids.box_display.add_widget(temp_click) pages = self.data_list.get_the_number_of_page("r") self.count_the_page = "Total pages to read: {}".format(pages) self.root.ids.req_book.state = 'down' self.root.ids.comp_book.state = 'normal'
def edit_book(self, name, author=None, year=0, description=None): this_book = Book(name, author, year, description) if this_book not in self._book_list: return False self.delete_book(this_book.name) self._book_list.append(this_book) return True
def add_record(self, book): """ Adds a new record of a book to the file.If there is a book record with the same title,author and year of publication then the book is recorded and we only change the number of copies of the recorded book.Otherwise, we add the new book. """ with open(self.file, 'r') as file: data = file.readlines() try: _file = self.file enum = enumerate(data) I = next(i for i, v in enum if Book.book_by_record(v) == book) os.rename(os.path.realpath(_file), os.path.realpath(_file)+".bak") copies = int(data[I].rstrip('\n').split('+')[-1]) book_update = book.special_record().rstrip('\n').split('+') book_update[-1] = str(int(book_update[-1]) + copies) data[I] = '+'.join(book_update) + '\n' with open(_file, 'w') as file: file.writelines(data) os.remove(os.path.realpath(self.file)+".bak") except StopIteration: data.append(book.special_record()) with open(self.file, 'a') as file: file.write(book.special_record())
def __init__(self, conn_details, status_light): """Setup a connection to MPD to be able to play audio. Also update the MPD database with any new MP3 files that may have been added and clear any existing playlists. """ self.status_light = status_light self.book = Book() self.book_titles = [] self.index_lock = RLock() self.current_index = -1 self.mpd_client = LockableMPDClient() with self.mpd_client: self.mpd_client.connect(**conn_details) self.mpd_client.update() self.mpd_client.clear() self.mpd_client.setvol(100) files = self.mpd_client.search("filename", ".mp3") if not files: self.status_light.interrupt("blink_fast", 3) else: for file in files: book_title = os.path.dirname(file["file"]) + "/" if book_title not in self.book_titles: self.book_titles.append(book_title)
def get_our_book(): orders = bitfloor.orders() our_book = { 'bids': {}, 'asks': {} } our_book2 = { 'bids': [], 'asks': [] } for o in orders: size = D(str(o['size'])) price = D(str(o['price'])) order = Order(size, price) order.id = o['order_id'] # TODO: hacky tup = (str(price), str(size)) if o['side'] == 0: our_book['bids'].setdefault(price, []).append(order) our_book2['bids'].append(tup) elif o['side'] == 1: our_book['asks'].setdefault(price, []).append(order) our_book2['asks'].append(tup) return our_book, Book.parse(our_book2)
def test_book_by_record(self): book = Book.book_by_record("Fall+Carl Jon+1999+Crime+3+2") self.assertEqual( "<Book Information>\nTitle:Fall\nAuthor:Carl " + "Jon\nPublished in:1999\nGenre:Crime\n" + "Rating:3.0\nNumber of copies:2\n", str(book), )
def entirebook(self,ordergrouping=1): #Open orders book with bids and asks url = "order_book/" params = {"group":ordergrouping} #group orders with the same price (0 - false; 1 - true). Default: 1 orderbook = self.get(url,params) from book import Book entirebook = Book.parse(orderbook) entirebook.sort() return entirebook #Returns a sorted Book class object,containing entirebook.bids and entirebook.asks
class TestPlayerOneLogic(unittest.TestCase): ''' Unittests for the logic patterns if the book is the first player ''' def setUp(self): self.grid = Grid() self.book = Book('X') def run_game(self, moves): '''Actually runs the game until someone wins, or there are no more squares available ''' while not self.grid.test_win() and self.grid.get_available(): self.grid = self.book.check_grid(self.grid) try: self.grid = self.grid.fill_square(user='******', square=moves.pop()) except: break def test_first_center_corner(self): ''' Game for the second player taking the center, then a corner ''' moves = ['5', '7', '2'] moves.reverse() # reversing so I can pop them off self.run_game(moves) self.assertEquals(self.grid.test_win(), 'X') def test_first_center_edge(self): ''' Game for the second player taking the center, then an edge ''' moves = ['5', '8', '3', '4'] moves.reverse() self.run_game(moves) self.assertFalse(self.grid.get_available()) def test_first_corner(self): ''' Game for the second player taking a corner ''' moves = ['3', '5', '4'] moves.reverse() self.run_game(moves) self.assertEquals(self.grid.test_win(), 'X') def test_first_edge_nothreat(self): ''' Game where the second player takes an edge, followed by a non-threat move ''' moves = ['4', '9', '7'] moves.reverse() self.run_game(moves) self.assertEquals(self.grid.test_win(), 'X') def test_first_edge_threat(self): ''' Game where the second player takes an edge, followed by a threat ''' moves = ['6', '9', '7'] moves.reverse() self.run_game(moves) self.assertEquals(self.grid.test_win(), 'X')
def __init__(self, conn_details, status_light): """Setup a connection to MPD to be able to play audio. Also update the MPD database with any new MP3 files that may have been added and clear any existing playlists. """ self.status_light = status_light self.book = Book() self.mpd_client = LockableMPDClient() self.init_mpd(conn_details)
def __init__(self): self.series = Series() self.author = Author() self.book = Book() self.whenRead = WhenRead() #establish list of fields the book method is purely responsible for # updating self.bookOnlyFields = ['book_id', 'title', 'notes', 'published', 'owner_status_id', 'read_status_id', 'type_id', 'series_num']
def load_books(self): print("Loading books...") if self.has_books: accordion = self.index_soup.find('div', attrs={'id': 'accordion'}) panels = accordion.find_all('div', attrs={'class': 'panel'}) for panel in panels: book = Book() book.number = int(panel.find('h4').find('span', attrs={'class': 'book'}).get_text()) if self.skip_first: book.number -= 1 if book.number == 0: continue book.number = str(book.number) if book.number not in self.chosen_books: continue book.title = panel.find('h4').find('span', attrs={'class': 'title'}).find('a').get_text().strip() links = panel.find('div', attrs={'class': 'panel-body'}).find_all('a') for link in links: book.add_chapter(Chapter(url=link.get('href'), title=link.get_text().strip())) self.books.append(book) print("Book {} done!".format(book))
def start_game(grid, human): ''' Starts the actual tic-tac-toe game ''' if human == 'O': ai = Book('X') else: ai = Book('O') while 1==1: # A turn for the human if they want to go first. grid.print_grid() square = raw_input("What square would you like to fill? (1-9) ") if square[0] in grid.get_available(): grid = grid.fill_square(user=human, square=square[0]) break else: print "I'm sorry, %s isn't available." % square # Main game loop while 1 == 1: grid = ai.check_grid(grid) if grid.test_win(): grid.print_grid() print "Computer won!" break while 1==1: grid.print_grid() square = raw_input("What square would you like to fill? (1-9) ") available = grid.get_available() if square[0] not in available: print "I'm sorry, %s isn't available." % square else: grid = grid.fill_square(user=human, square=square[0]) grid.print_grid() break if grid.test_win() == 'Draw': print "Draw! No one won!" break if grid.test_win(): print "You won!" break
class TestBook(unittest.TestCase): ''' Unittest for the book class (just the non-logic functions. Logic is tested elsewhere) ''' def setUp(self): self.grid = Grid() self.book = Book('X') def test_check_win(self): ''' Book can detect a threat ''' self.grid.fill_square(user='******', square='1') self.grid.fill_square(user='******', square='2') self.grid, win = self.book.check_win(grid=self.grid, player='X') self.assertEquals(self.grid.test_win(), 'X')
def _get_book_from_json_dict(self, data): """ Create a new Book instance based on a JSON dict. @param data: a JSON dictionary @return: a new Book instance (sans ISBN) """ publishers = ', '.join([self._get_publisher_from_json_dict(p) for p in data['publishers']]) authors = ', '.join([self._get_author_from_json_dict(a) for a in data['authors']]) book = Book(0) # better to create an object, even if there's no valid barcode yet book.title = data.get('title', None) book.publisher = publishers book.authors = authors book.pages = data.get('number_of_pages', None) # might cause issue, be careful. book.publ_year = data.get('publish_date', None) book.description = data.get('excerpts', None) return book
class Indexable(Persistent): # prepend _v_ to make it volatilive _v_book = None def __init__(self): self._v_book = Book() self._v_book.addData(self) def __setattr__(self, name, value): #only run this if the name is within the current objects attributes if self._v_book and name not in Persistent.__dict__: # if the book exists AND # if the value has changed # and that attribute is an indexable attribute # OR we want it to be indexed, however it is not actually in the index (this condition will be caught # in updateIndexedValue) if self._v_book and self.__dict__.get(name) != value and name in self.indexableAttrs: self._v_book.updateIndexedValue(self, name, value) # save changes self._v_book.commitTransaction() Persistent.__setattr__(self, name, value) #TODO def __delattr__(self, name): pass