def downloaded_files():
try:
_logger = logger('downloaded_files')
import os
import datetime
current_directory = os.getcwd()
_dir = os.path.join(current_directory, r'Downloads')
if not os.path.exists(_dir):
os.makedirs(_dir)
ext = [".epub", ".py", ".pdf", ".docx", ".zip"]
files = []
for fn in os.listdir(_dir):
for ex in ext:
if fn.endswith(ex):
files.append(fn)
file_details = []
for f in files:
info = []
path = os.path.join(_dir, f)
info.append(f)
info.append("size:" + str(os.stat(path).st_size) + " bytes")
info.append(
"modified:" +
str(datetime.datetime.fromtimestamp(os.stat(
path).st_mtime))[:-10] + "")
file_details.append(info)
if file_details == []:
file_details = [["No Book in Downloads"]]
return file_details
except:
_logger.error('application exited with exception: %r' %
traceback.format_exc())
raise
finally:
pass
def main(stdscr, args):
top, left = stdscr.getbegyx() # top left coordinate of the screen
rows, cols = stdscr.getmaxyx() # size of screen
console.init(stdscr)
from console.logger import logger
_logger = logger('main')
try:
from os import path
import traceback
from console.application import Application
from console.ui.editor import Editor
from console.ui.window import Window, EditorWindow, PromptWindow
from console.enums import DEFAULT_WINDOW
from console.config import PROMPT_HEIGHT
from console.core.prompt_buffer import PromptBuffer
# from binding import load_custom_binding
_logger.debug('terminal size %dx%d' % (rows, cols))
#--------------------------------------------------
book_buffer = ReaderBuffer()
book_buffer.is_readonly = False
booklistwindow = EditorWindow(name=BOOKLIST_WINDOW,
top=top,
left=left,
rows=rows - PROMPT_HEIGHT,
columns=cols,
buf=book_buffer,
wrap=True)
#--------------------------------------------------
login_buffer = LoginBuffer()
login_buffer.is_readonly = False
loginwindow = EditorWindow(name=LOGIN_WINDOW,
top=top,
left=left,
rows=rows - PROMPT_HEIGHT,
columns=cols,
buf=book_buffer,
wrap=True)
#---------------------------------------------------
edit_buffer = PromptBuffer()
edit_buffer.is_readonly = False
editwindow = EditorWindow(name=DEFAULT_WINDOW,
top=top,
left=left,
rows=rows - PROMPT_HEIGHT,
columns=cols,
buf=edit_buffer,
wrap=False)
editor = Editor(
rows - PROMPT_HEIGHT, # editable area height
cols, # editable area width
rows - PROMPT_HEIGHT, # prompt row
PROMPT_HEIGHT, # height of prompt window(1)
cols,
windows=[editwindow, booklistwindow, loginwindow], #
initial_focused_window=BOOKLIST_WINDOW) #BOOKLIST_WINDOW )
registry = MergedRegistry(
[console.default_bindings(),
load_custom_binding()])
app = Application(editor, registry=registry)
app.run()
except:
_logger.error('application exited with exception: %r' %
traceback.format_exc())
raise
finally:
pass
def delete(self):
_logger = logger('reader_buffer')
_logger.error(': deleting file...')
class ReaderBuffer(BufferBase):
_logger = logger('reader-buffer')
def __init__(self, name='', text=''):
BufferBase.__init__(self, name)
self._text = text
self._files = downloaded_files()
self.lvl = 0
self.index = 0
@property
def text(self):
return self._files[self.lvl][self.index]
@text.setter
def text(self, value):
self._text = value
self.emit(EventType.TEXT_CHANGED)
def cursor_right(self):
self.index += 1
if self.index > len(self._files[self.lvl]) - 1:
self.index = 0
self.emit(EventType.TEXT_CHANGED)
def cursor_left(self):
self.index -= 1
if self.index < 0:
self.index = len(self._files[self.lvl]) - 1
self.emit(EventType.TEXT_CHANGED)
def cursor_up(self):
self.index = 0
self.lvl -= 1
if self.lvl < 0:
self.lvl = len(self._files) - 1
self.emit(EventType.TEXT_CHANGED)
def cursor_down(self):
self.index = 0
self.lvl += 1
if self.lvl > len(self._files) - 1:
self.lvl = 0
self.emit(EventType.TEXT_CHANGED)
def top(self):
pass
def bottom(self):
pass
def enter(self):
_logger = logger('reader_buffer')
_logger.error(': opening selected file...')
def delete(self):
_logger = logger('reader_buffer')
_logger.error(': deleting file...')
def enter(self):
_logger = logger('reader_buffer')
_logger.error(': opening selected file...')
class ReaderBuffer(BufferBase):
_logger = logger('reader-buffer')
try:
def __init__(self, name='', text=''):
BufferBase.__init__(self, name)
self._text = text
# _files=downloaded_files()
# if _files==[]:
# self._files=[["No Books in Download"]]
# else:
# self._files = _files
self._files = downloaded_files()
self.prev_files = []
self.lvl = 0
self.prev_lvl = 0
self.index = 0
self.prev_index = 0
self.prev_total_books = 0
# self.end_msg="end of list"
@property
def text(self):
return self._files[self.lvl][self.index]
@text.setter
def text(self, value):
self._text = value
self.emit(EventType.TEXT_CHANGED)
def cursor_right(self):
self.index += 1
if self.index > len(self._files[self.lvl]) - 1:
# self.index=len(self._files[self.lvl])-1
self.index = 0 #circular movement
self.emit(EventType.TEXT_CHANGED)
def cursor_left(self):
self.index -= 1
if self.index < 0:
# self.index=0
self.index = len(self._files[self.lvl]) - 1 #circular movement
self.emit(EventType.TEXT_CHANGED)
def cursor_up(self):
self.index = 0
self.lvl -= 1
if self.lvl < 0:
self.lvl = 0
# self.lvl=len(self._files)-1 #circular movement
self.emit(EventType.TEXT_CHANGED)
def cursor_down(self):
self.index = 0
self.lvl += 1
if self.lvl > len(self._files) - 1:
self.lvl = len(self._files) - 1
# self.lvl=0 #circular movement
self.emit(EventType.TEXT_CHANGED)
@property
def is_readonly(self):
return self._readonly_document
@is_readonly.setter
def is_readonly(self, value):
self._readonly_document = value
def top(self):
pass
def bottom(self):
self.index = 0
self.lvl = -1
try:
self.emit(EventType.TEXT_CHANGED)
except:
pass
def reset(self):
self.index = 0
self.lvl = 0
try:
self.emit(EventType.TEXT_CHANGED)
except:
pass
def enter(self, file_path):
_logger = logger('reader_buffer')
_logger.error(file_path)
def delete(self):
_logger = logger('reader_buffer')
_logger.error(' deleting file...')
def go_to_prev_state(self):
self.index = self.prev_index
self.lvl = self.prev_lvl
self._files = self.prev_files
self.emit(EventType.TEXT_CHANGED)
except:
_logger.error('application exited with exception: %r' %
traceback.format_exc())
raise
finally:
pass
class ReaderBuffer(BufferBase):
_logger = logger('reader-buffer')
def __init__(self, name='', text=''):
BufferBase.__init__(self, name)
self._text = text
# _files=downloaded_files()
# if _files==[]:
# self._files=[["No Books in Download"]]
# else:
# self._files = _files
self._files = downloaded_files()
self.prev_files = []
self.lvl = 0
self.prev_lvl = 0
self.index = 0
self.prev_index = 0
@property
def text(self):
return self._files[self.lvl][self.index]
@text.setter
def text(self, value):
self._text = value
self.emit(EventType.TEXT_CHANGED)
def cursor_right(self):
self.index += 1
if self.index > len(self._files[self.lvl]) - 1:
self.index = len(self._files[self.lvl]) - 1
# self.index=0
self.emit(EventType.TEXT_CHANGED)
def cursor_left(self):
self.index -= 1
if self.index < 0:
self.index = 0
# self.index=len(self._files[self.lvl])-1
self.emit(EventType.TEXT_CHANGED)
def cursor_up(self):
self.index = 0
self.lvl -= 1
if self.lvl < 0:
self.lvl = 0
# self.lvl=len(self._files)-1
self.emit(EventType.TEXT_CHANGED)
def cursor_down(self):
self.index = 0
self.lvl += 1
if self.lvl > len(self._files) - 1:
self.lvl = len(self._files) - 1
# self.lvl=0
# if pcs.menu_lvl=="11" and sp.latest_page>1:
# self.lvl = len(self._files)
# sp.get_latest_books()
self.emit(EventType.TEXT_CHANGED)
@property
def is_readonly(self):
return self._readonly_document
@is_readonly.setter
def is_readonly(self, value):
self._readonly_document = value
def top(self):
pass
def bottom(self):
pass
def reset(self):
self.index = 0
self.lvl = 0
try:
self.emit(EventType.TEXT_CHANGED)
except:
pass
def enter(self):
_logger = logger('reader_buffer')
_logger.error(' opening selected file...')
def delete(self):
_logger = logger('reader_buffer')
_logger.error(' deleting file...')
def go_to_prev_state(self):
self.index = self.prev_index
self.lvl = self.prev_lvl
self._files = self.prev_files
self.emit(EventType.TEXT_CHANGED)
def load_custom_binding():
_logger = logger('load_custom_binding')
try:
registry = Registry(EditorWindow)
handle = registry.add_binding
window_name = "MENU_LIST"
from reader import process_choice_selection
pcs = process_choice_selection(window_name)
@handle(Keys.Home)
def _(event):
try:
event.app.editor.focus(BOOKLIST_WINDOW)
event.current_window.buffer._files = downloaded_files()
event.current_window.buffer.reset()
event.current_window.buffer.emit(EventType.TEXT_CHANGED)
except Exception as e:
event.app.editor.error('unknown error %r' % e)
@handle(Keys.ControlH)
def _(event):
try:
from login import _login
pcs.sp = None
pcs.bs = None
pcs.login = _login()
except:
pass
lst = [
MenuItem('sugamya pustkalaya', 's',
lambda app: pcs.choice_selection(event, "1")),
MenuItem('bookshare', 'b',
lambda app: pcs.choice_selection(event, "2")),
# MenuItem('gutenberg','3', lambda app: pcs.choice_selection(event,"3")),
# MenuItem('local books','4', lambda app: pcs.choice_selection(event,"4")),
MenuItem('quits', 'q',
lambda app: pcs.choice_selection(event, "q")),
]
pcs.get_user_input(event.app, lst)
# @handle(Keys.Delete)
# def _(event):
# try:
# event.current_window.buffer.delete()
# except Exception as e:
# event.app.editor.error('unknown error %r' % e)
# @handle(Keys.Left)
# @handle(Keys.BackTab)
# def _(event):
# try:
# if event.current_window.buffer._files==[]:
# event.app.editor.error('No book found')
# else:
# event.current_window.buffer.cursor_left()
# except Exception as e:
# event.app.editor.error('unable to navigate %r' % e)
# @handle(Keys.Right)
@handle(' ')
def _(event):
try:
event.app.editor.focus(BOOKLIST_WINDOW)
if event.current_window.buffer._files == []:
event.app.editor.error('No book found Space')
else:
event.current_window.buffer.cursor_right()
except Exception as e:
event.app.editor.error('unable to navigate %r' % e)
@handle(Keys.Up)
def _(event):
try:
handle = None
if pcs.menu == "sp":
handle = pcs.sp
elif pcs.menu == "bs":
handle = pcs.bs
event.app.editor.focus(BOOKLIST_WINDOW)
buf = event.current_window.buffer
lvl = buf.lvl
if not handle == None and lvl == 0:
event.app.editor.error('start of list')
elif event.current_window.buffer._files == []:
event.app.editor.error('No book found UP')
else:
event.current_window.buffer.cursor_up()
except Exception as e:
event.app.editor.error('unable to navigate %r' % e)
@handle(Keys.Down)
def _(event):
try:
handle = None
if pcs.menu == "sp":
handle = pcs.sp
elif pcs.menu == "bs":
handle = pcs.bs
event.app.editor.focus(BOOKLIST_WINDOW)
buf = event.current_window.buffer
if buf._files == []:
event.app.editor.error('No book found DOwn')
lvl = buf.lvl
if not handle == None and lvl == len(
handle.book_repo) - 1 and handle.total_books == str(
len(handle.book_repo)):
event.app.editor.error('end of list')
elif not handle == None and lvl == len(handle.book_repo) - 1:
if pcs.menu_lvl in ["1-4"]:
buf.cursor_down()
else:
event.app.editor.focus(BOOKLIST_WINDOW)
handle.pre_fetch_books()
buf._files = handle.book_repo
buf.lvl = lvl + 1
buf.index = 0
buf.emit(EventType.TEXT_CHANGED)
else:
buf.cursor_down()
except Exception as e:
event.app.editor.error('unable to navigate %r ' %
str(e)[0:50])
def _search_book_id(*args):
event = args[0]
book_id = str(args[-1])
if book_id == "" or ' ' in book_id:
get_book_id_input(event)
try:
pcs.handle.get_book_id(book_id)
pcs.menu_lvl = "1-1-id"
except IndexError:
event.app.editor.message('Book not Found id')
except Exception as e:
event.app.editor.error(' %r ' % str(e)[0:60])
def get_book_id_input(event):
event.app.editor.input('search with id:',
"PROMPT_WINDOW",
on_ok_handler=_search_book_id)
# @handle(Keys.ControlF)
# def _(event):
# if pcs.menu=="sp":
# pcs.handle=pcs.sp
# choice="1"
# elif pcs.menu=="bs":
# pcs.handle=pcs.bs
# choice="2"
# if not handle==None and pcs.menu_lvl in ["1-1"]:
# get_book_id_input(event)
@handle(Keys.ControlR)
def _(event):
if not pcs.sp == None and pcs.menu_lvl in [
"1-1", "1-2", "1-3-b", "1-4-b"
]:
try:
event.app.editor.focus(BOOKLIST_WINDOW)
lvl = pcs._event.current_window.buffer.lvl
book_id = pcs.sp.book_repo[lvl][-1].split("(")[0].strip(
).split(":")[-1].strip() #pcs.sp.book_repo[lvl][-1][3:]
# event.app.editor.error(' %r ' % book_id)
pcs.sp.request_book_download(book_id)
except Exception as e:
event.app.editor.error(' %r ' % e)
@handle(Keys.PageUp)
def _(event):
handle = None
if pcs.menu == "sp":
handle = pcs.sp
elif pcs.menu == "bs":
handle = pcs.bs
if not handle == None and pcs.menu_lvl in [
"1-1",
"1-2",
"1-3-b",
"1-4",
"1-4-b",
"1-5",
]:
event.app.editor.focus(BOOKLIST_WINDOW)
pcs._event.current_window.buffer.reset()
@handle(Keys.PageDown)
def _(event):
handle = None
if pcs.menu == "sp":
handle = pcs.sp
elif pcs.menu == "bs":
handle = pcs.bs
if not handle == None and pcs.menu_lvl in [
"1-1", "1-2", "1-3-b", "1-4", "1-4-b", "1-5"
]:
event.app.editor.focus(BOOKLIST_WINDOW)
pcs._event.current_window.buffer.index = 0
pcs._event.current_window.buffer.lvl = len(
handle.book_repo) - 1
pcs._event.current_window.buffer.emit(EventType.TEXT_CHANGED)
# pcs._event.current_window.buffer.bottom()
@handle(Keys.Backspace)
def _(event):
handle = None
if pcs.menu == "sp":
handle = pcs.sp
choice = "1"
elif pcs.menu == "bs":
handle = pcs.bs
choice = "2"
if not handle == None and pcs.menu_lvl in [
"1", "2", "1-1", "1-2", "1-3", "1-3-b", "1-3-e", "1-4",
"1-4-b", "1-5", "1-m", "1-e"
]:
if pcs.menu_lvl in ["1-m", "1-4-b"]:
event.app.editor.focus(BOOKLIST_WINDOW)
pcs._event.current_window.buffer.go_to_prev_state()
pcs.menu_lvl = pcs.prev_menu_lvl
handle.book_repo = pcs._event.current_window.buffer._files
handle.total_books = pcs._event.current_window.buffer.prev_total_books
if pcs.menu_lvl in ["1-3-e", "1-3-b"]:
pcs.menu_lvl == "1-3"
pcs._event.current_window.buffer.reset()
pcs.get_user_input(event.app, pcs.search_menu_lst)
else:
try:
event.app.editor.focus(BOOKLIST_WINDOW)
pcs._event.current_window.buffer._files = downloaded_files(
)
pcs._event.current_window.buffer.reset()
pcs.choice_selection(event, choice)
except Exception as e:
event.app.editor.error(' %r ' % e)
@handle(Keys.ControlD)
def _(event):
if pcs.menu == "sp" and pcs.menu_lvl in ["1-5"]:
try:
event.app.editor.focus(BOOKLIST_WINDOW)
lvl = pcs._event.current_window.buffer.lvl
book_id = pcs.sp.book_repo[lvl][-1].split("(")[0].strip(
).split(":")[-1].strip() #pcs.sp.book_repo[lvl][-1][3:]
event.app.editor.message('downloading...')
import threading
t = threading.Thread(target=pcs.sp.download_book,
args=(book_id, ))
t.start()
pcs.sp.download_threads.append(t)
except Exception as e:
event.app.editor.error(' %r ' % str(e)[0:60])
if pcs.menu == "bs" and pcs.menu_lvl in [
"1-1", "1-2", "1-3-b", "1-4-b", "1-m"
]:
try:
event.app.editor.focus(BOOKLIST_WINDOW)
lvl = pcs._event.current_window.buffer.lvl
# repo=pcs._event.current_window.buffer._files[-1]
# book_id=pcs.remove_book_index([repo])[-1][-1]
book_id = pcs.bs.book_repo[lvl][-1].split("(")[0].strip(
).split(":")[-1].strip() #pcs.sp.book_repo[lvl][-1][3:]
# event.app.editor.message('downloading...')
pcs.bs.book_download(book_id)
# import threading
# t_bs=threading.Thread(target=pcs.bs.book_download, args=(book_id,))
# t_bs.start()
# pcs.bs.download_threads.append(t)
except Exception as e:
event.app.editor.error(' %r ' % str(e)[0:60])
@handle(Keys.Enter)
def _(event):
handle = None
if pcs.menu == "sp":
handle = pcs.sp
choice = "1"
elif pcs.menu == "bs":
handle = pcs.bs
choice = "2"
if not handle == None and pcs.menu_lvl in ["1-4"]:
handle.c_page_index = 1
try:
event.app.editor.focus(BOOKLIST_WINDOW)
# handle.book_repo_temp=handle.book_repo
lvl = pcs._event.current_window.buffer.lvl
handle.category_name = handle.book_repo[lvl][-1].split(
"(")[0].strip()
handle.book_repo = []
handle.c_book_repo = []
# pcs._event.current_window.buffer.reset()
handle.category_book_search(handle.category_name)
except Exception as e:
event.app.editor.error(' %r ' % e)
if pcs.menu_lvl in ["1-3-e"]:
pcs.menu_lvl == "1-3"
pcs.get_user_input(event.app, pcs.search_menu_lst)
if not handle == None and pcs.menu_lvl in ["1-e"]:
# from local_books import downloaded_files
try:
event.app.editor.focus(BOOKLIST_WINDOW)
pcs._event.current_window.buffer._files = downloaded_files(
)
pcs._event.current_window.buffer.reset()
pcs.choice_selection(event, choice)
except Exception as e:
event.app.editor.error(' %r ' % e)
if not handle == None and pcs.menu_lvl in ["1-m"]:
# from local_books import downloaded_files
try:
event.app.editor.focus(BOOKLIST_WINDOW)
pcs._event.current_window.buffer.go_to_prev_state()
pcs.menu_lvl = pcs.prev_menu_lvl
## pcs._event.current_window.buffer._files= downloaded_files()
## pcs._event.current_window.buffer.reset()
# pcs.choice_selection(event, choice)
except Exception as e:
event.app.editor.error(' %r ' % str(e)[0:60])
if handle == None:
try:
import os
current_directory = os.getcwd()
_dir = os.path.join(current_directory, r'Downloads')
event.app.editor.focus(BOOKLIST_WINDOW)
lvl = event.current_window.buffer.lvl
f = event.current_window.buffer._files[lvl][0]
path = os.path.join(_dir, f)
event.current_window.buffer.enter(path)
except Exception as e:
event.app.editor.error(' %r ' % str(e)[0:60])
return registry
except:
_logger.error('application exited with exception: %r' %
traceback.format_exc())
raise
finally:
pass
def enter(self, file_path):
_logger = logger('reader_buffer')
_logger.error(file_path)
class _login():
_logger = logger('_login')
try:
def __init__(self):
self.userid = None
self.password = None
self.login_lvl = None
self.event = None
self.pcs = None
self.login_status = 0
self.login_tag = ""
def _on_password_ok(self, *args):
self.password = str(args[-1])
# self.event.app.editor.error(str(self.pcs.sp.check_credentials(self.userid,self.password)))
if self.login_tag == "sp":
self.password = "******"
handle = self.pcs.sp
choice = "1"
response = handle.check_credentials(self.userid, self.password)
if response == 1:
self.login_status = 1
self.login_lvl = self.login_tag
handle.login_status = True
self.pcs.next_func()
else:
if self.pcs.menu_lvl in ["1-5"]:
self.pcs.choice_selection(self.event, choice)
self.event.app.editor.error(str(response))
# if self.login_tag=="bs":
# self.password="******"
# handle=self.pcs.bs
# choice="2"
def get_password(self):
self.event.app.editor.input('password:'******'userid:',
"PROMPT_WINDOW",
on_ok_handler=self._on_userid_ok)
except:
_logger.error('application exited with exception: %r' %
traceback.format_exc())
raise
finally:
pass
class LoginBuffer(BufferBase):
_logger = logger('login-buffer')
def __init__(self, name = '' ,text=""):
BufferBase.__init__(self, name)
self._text = text
self.userid=""
self.password=""
@property
def text(self):
return self._text
@text.setter
def text(self, value):
self._text = value
self.emit(EventType.TEXT_CHANGED)
@property
def cursor(self):
return self._cursor
@cursor.setter
def cursor(self, value):
self._cursor = value
if self._cursor >= len(self.text):
if self.is_readonly:
self._cursor = max(len(self.text) - 1, 0)
else:
self._cursor = len(self.text)
if self._cursor < 0:
self._cursor = 0
self.emit(EventType.CURSOR_MOVED)
@property
def is_readonly(self):
return self._readonly_document
@is_readonly.setter
def is_readonly(self, value):
self._readonly_document = value
@property
def selection_range(self):
return None
@property
def format_ranges (self):
return []
def insert_text(self, ch):
if self.is_readonly:
BufferBase._logger.debug('buffer is readonly')
return
text = chr(ch)
if len(self.text) == 0:
self._text = text
else:
first = u''
last = u''
if self._cursor > 0:
first = self.text[:self._cursor]
if self._cursor <= len(self.text):
last = self.text[self._cursor:]
self._text = first + text + last
self._cursor += 1
self.emit(EventType.TEXT_CHANGED)
def remove(self, count = -1):
if self.is_readonly:
BufferBase._logger.debug('buffer is readonly')
return
# nothing to delete
if (len(self.text) == 0 or
(self.cursor == 0 and count < 0) or
(self.cursor == len(self.text) and count > 0)):
return
first = u''
last = u''
if count < 0: # backspace
count = -count
first = self.text[:self._cursor - count]
if self._cursor < len(self.text):
last = self.text[self._cursor:]
self._cursor -= count
else: # delete
last = self.text[self._cursor + count:]
if self._cursor > 0:
first = self.text[:self._cursor]
self._text = first + last
self.emit(EventType.TEXT_CHANGED)
def enter(self):
pass
def cursor_up(self, rows = 1):
pass
def cursor_down(self, rows = 1):
pass
def cursor_left(self, cols = 1):
self.cursor = self.cursor - cols
def cursor_right(self, cols = 1):
self.cursor = self.cursor + cols
def cursor_beg(self):
self.cursor = 0
def cursor_end(self):
self.cursor = len(self.text)
def top(self):
pass
def bottom(self):
pass
def previous(self, blocktype):
return None
def next(self, blocktype):
return None
def delete(self):
pass
# search and replace
def reset_search(self):
self._new_search = True
self._search_text = None
def search(self, search_text, back_search):
raise NotImplementedError
def _find_match(self, back_search):
raise NotImplementedError
def next_match(self, search_text, back_search, from_top = False):
return None
def replace(self, search_text, replace_text, back_search):
return None
def replace_all(self, search_text, replace_text, back_search):
return None
# clipboard
def clipboard_copy(self):
self.toggle_property(BufferBase.PROPERTY_SELECTION, reset = False)
BufferBase._logger.info('clipboard_copy not implemented')
def clipboard_cut(self):
self.toggle_property(BufferBase.PROPERTY_SELECTION, reset = False)
BufferBase._logger.info('clipboard_cut not implemented')
def clipboard_paste(self):
BufferBase._logger.info('clipboard_paste not implemented')
def clipboard_delete(self):
self.toggle_property(BufferBase.PROPERTY_SELECTION, reset = False)
BufferBase._logger.info('clipboard_delete not implemented')
def toggle_property(self, prop, **args):
if prop == BufferBase.PROPERTY_READONLY:
self._readonly_document = not self._readonly_document
self.focus()
elif prop == BufferBase.PROPERTY_BOLD:
self._bold_forced_on = not self._bold_on
self._bold_on = self._bold_forced_on
elif prop == BufferBase.PROPERTY_ITALIC:
self._italic_forced_on = not self._italic_on
self._italic_on = self._italic_forced_on
elif prop == BufferBase.PROPERTY_UNDERLINE:
self._underline_forced_on = not self._underline_on
self._underline_on = self._underline_forced_on
elif prop == BufferBase.PROPERTY_SELECTION:
if self._selection_on:
reset = args.pop('reset', True)
self.emit(EventType.TEXT_CHANGED)
else:
self.emit(EventType.TEXT_CHANGED)
self._selection_on = not self._selection_on
else:
pass
def get_property(self, prop):
if prop == BufferBase.PROPERTY_READONLY:
return self._readonly_document
elif prop == BufferBase.PROPERTY_BOLD:
return self._bold_on
elif prop == BufferBase.PROPERTY_ITALIC:
return self._italic_on
elif prop == BufferBase.PROPERTY_UNDERLINE:
return self._underline_on
elif prop == BufferBase.PROPERTY_SELECTION:
return self._selection_on
else:
return None
def set_property(self, prop, value):
assert isinstance(value, bool)
if prop == BufferBase.PROPERTY_READONLY:
self._readonly_document = value
elif prop == BufferBase.PROPERTY_BOLD:
self._bold_on = value
elif prop == BufferBase.PROPERTY_ITALIC:
self._italic_on = value
elif prop == BufferBase.PROPERTY_UNDERLINE:
self._underline_on = value
elif prop == BufferBase.PROPERTY_SELECTION:
self._selection_on = value
else:
raise ValueError('invalid property name')
@property
def is_selection_on(self):
return self._selection_on
class SugamyaPustakalya():
try:
_logger = logger('SugamyaPustakalya')
# KEY = 'D72551A2C3319E892DF355AAB1C55FCEEAE91A2236C39B931513155440537'
KEY = os.environ.get(str(sugamya_key))
URL = 'https://library.daisyindia.org/NALP/rest/NALPAPIService/getNALPData/'
def __init__(self, pcs):
self.pcs = pcs
self.WINDOW = "BOOKLIST_WINDOW"
self.userid = None
self.password = None
self.book_repo = []
self.book_repo_temp = []
self.l_page_index = 1
self.p_page_index = 1
self.s_page_index = 1
self.c_page_index = 1
self.d_page_index = 1
self._on_search_ok = None
self.search_input = ""
self.all_urls = {}
self.category_name = ""
self.download_threads = []
self.login_status = False
self.l_book_repo = []
self.p_book_repo = []
self.s_book_repo = []
self.c_book_repo = []
self.d_book_repo = []
self.total_books = "0"
def check_credentials(self, userid, password):
self.userid = userid
self.password = password
page = 1
try:
data = requests.get(self.URL + 'latest/page/' + str(page) +
'/limit/20/format/JSON?API_key=' +
self.KEY,
verify=False)
try:
authString = self.userid + ":" + self.password
# authString = "26353" + ':' +"9m85twwz"
encoded = base64.b64encode(bytearray(
authString.encode())).decode()
headers = {
'Authorization': 'Basic ' + encoded,
"page": "1",
"limit": "1",
"format": "xml",
"API_key": self.KEY
}
data = requests.post(
"https://library.daisyindia.org/NALP/rest/NALPAPIService/fetchUserDownloadRequests",
headers=headers,
verify=False)
if (data.status_code == 200):
parsedData = minidom.parseString(data.text)
msg = parsedData.getElementsByTagName('message')
if msg == []:
return 1
else:
return "invalid credentials..."
else:
err = "Error:" + str(data) + str(data.status_code)
return err
except Exception as e:
return str(e.message)
except Exception as e:
self.userid = None
self.pcs.menu_lvl = "1-e"
msg = str(e) #"Network unreachable"
self.pcs.show_msg(msg)
# self.pcs._event.app.editor.error('Network is unreachable')
def fetch_books(self, menu):
if menu == "latest":
self.menu_lvl = "1-1"
# choice="1"
page = self.l_page_index
repo = self.l_book_repo
url = self.URL + menu + '/page/' + str(
page) + '/limit/20/format/JSON?API_key=' + self.KEY
if menu == "popular":
self.menu_lvl = "1-2"
# choice="2"
page = self.p_page_index
repo = self.p_book_repo
url = self.URL + "popularbooks/noOfTimesDelivered/1/startDate/1017-01-01/endDate/4017-12-15/page/" + str(
page) + "/limit/250/format/xml?API_key=" + self.KEY
# page=1424
try:
data = requests.get(url, verify=False)
if (data.status_code == 200):
parsedData = minidom.parseString(data.text.encode('utf-8'))
books = parsedData.getElementsByTagName('result')
if (len(books) == 0):
s = parsedData.getElementsByTagName("string")
msg = ""
for i in s:
msg = msg + str(i.firstChild.nodeValue) + "."
if not repo == []:
self.pcs.copy_buffer()
self.pcs.menu_lvl = "1-m"
self.pcs.show_msg(msg)
# self.pcs._event.app.editor.focus(self.WINDOW)
# self.pcs._event.current_window.buffer._files = [[msg]]
# self.pcs._event.current_window.buffer.emit(EventType.TEXT_CHANGED)
else:
self.pcs.menu_lvl = "1-e"
self.pcs.show_msg(msg)
# self.pcs.bs_choice_selection(self.pcs._event, "1") #bs
# self.pcs._event.app.editor.error('Network is unreachable')
return
else:
# n=len(books)
self.total_books = parsedData.getElementsByTagName(
'total-results')[0].firstChild.nodeValue
# self.num_pages=parsedData.getElementsByTagName('num-pages')[0].firstChild.nodeValue
for i, book in enumerate(books):
row = []
for child in book.childNodes:
if (len(child.childNodes) !=
0) and child.tagName != "id":
row.append(
str(child.localName) + ":" +
str(child.firstChild.nodeValue))
row.append("id:" + str(
book.getElementsByTagName('id')
[0].firstChild.nodeValue))
repo.append(row)
repo = self.pcs.insert_book_index(
repo, self.total_books)
self.book_repo = repo
self.pcs._event.app.editor.focus(self.WINDOW)
self.pcs._event.current_window.buffer._files = self.book_repo
self.pcs._event.current_window.buffer.emit(
EventType.TEXT_CHANGED)
page += 1
if menu == "latest":
self.l_page_index = page
self.l_book_repo = repo
if menu == "popular":
self.p_page_index = page
self.p_book_repo = repo
else:
self.pcs.menu_lvl = "1-e"
msg = "Error, server replied with" + str(data.status_code)
self.pcs.show_msg(msg)
except Exception as e:
self.userid = None
self.pcs.menu_lvl = "1-e"
exc_type, exc_obj, tb = sys.exc_info()
lineno = tb.tb_lineno
msg = str(e) + str(lineno) #"Network unreachable"
self.pcs.show_msg(msg)
def pre_fetch_books(self):
if self.pcs.menu_lvl == "1-1":
menu = "latest"
page = self.l_page_index
repo = self.l_book_repo
url = self.URL + menu + '/page/' + str(
page) + '/limit/20/format/JSON?API_key=' + self.KEY
if self.pcs.menu_lvl == "1-2":
menu = "popular"
page = self.p_page_index
repo = self.p_book_repo
url = self.URL + "popularbooks/noOfTimesDelivered/1/startDate/1017-01-01/endDate/4017-12-15/page/" + str(
page) + "/limit/250/format/xml?API_key=" + self.KEY
if self.pcs.menu_lvl == "1-3-b":
menu = "search"
search = self.search_input
page = self.s_page_index
repo = self.s_book_repo
if self.pcs.search_lvl == "1":
url = self.URL + "id/" + search + "/page/" + str(
page) + "/limit/250/format/xml?API_key=" + self.KEY
if self.pcs.search_lvl == "2":
url = self.URL + "title/" + search + "/page/" + str(
page) + "/limit/250/format/xml?API_key=" + self.KEY
if self.pcs.search_lvl == "3":
url = self.URL + "author/" + search + "/page/" + str(
page) + "/limit/250/format/xml?API_key=" + self.KEY
if self.pcs.search_lvl == "4":
url = self.URL + "authortitle/" + search + "/page/" + str(
page) + "/limit/250/format/xml?API_key=" + self.KEY
# if self.pcs.search_lvl=="5":
# url=self.URL + "authortitle/" + search + "/page/"+str(page)+"/limit/250/format/xml?API_key=" + self.KEY
# url=self.URL + "authortitle/" +self.search_input + "/page/"+str(page)+"/limit/250/format/xml?API_key=" + self.KEY
if self.pcs.menu_lvl == "1-4-b":
menu = "category"
page = self.c_page_index
repo = self.c_book_repo
url = self.URL + "category/" + self.category_name + "/page/" + str(
page) + "/limit/52/format/xml?API_key=" + self.KEY
tmp_repo = []
self.queued_repo = []
# tmp_repo.append([str(page)])
try:
data = requests.get(
url,
verify=False) # during production remove verify = false
if (data.status_code == 200):
parsedData = minidom.parseString(data.text.encode('utf-8'))
books = parsedData.getElementsByTagName('result')
if (len(books) == 0):
s = parsedData.getElementsByTagName("string")
s = s[::-1]
msg = ""
for i in s:
msg = msg + str(i.firstChild.nodeValue) + "."
if not repo == []:
self.pcs.copy_buffer()
self.pcs.menu_lvl = "1-m"
self.pcs.show_msg(msg)
# self.pcs._event.app.editor.focus(self.WINDOW)
# self.pcs._event.current_window.buffer._files = [[msg]]
# self.pcs._event.current_window.buffer.emit(EventType.TEXT_CHANGED)
else:
if self.pcs.menu_lvl == "1-3-b":
self.pcs.menu_lvl = "1-3-e"
else:
self.pcs.menu_lvl = "1-e"
self.pcs.show_msg(msg)
self.pcs.show_msg(msg)
# self.pcs.bs_choice_selection(self.pcs._event, "1") #bs
# self.pcs._event.app.editor.error('Network is unreachable')
return
else:
self.total_books = parsedData.getElementsByTagName(
'total-results')[0].firstChild.nodeValue
for i, book in enumerate(books):
row = []
for child in book.childNodes:
if (len(child.childNodes) !=
0) and child.tagName != "id":
row.append(
str(child.localName) + ":" +
str(child.firstChild.nodeValue))
row.append("id:" + str(
book.getElementsByTagName('id')
[0].firstChild.nodeValue))
tmp_repo.append(row)
repo = self.pcs.remove_book_index(repo)
tmp_repo = repo + tmp_repo
tmp_repo = self.pcs.insert_book_index(
tmp_repo, self.total_books)
repo = tmp_repo
self.book_repo = repo
page += 1
if self.pcs.menu_lvl == "1-1":
self.l_page_index = page
self.l_book_repo = repo
if self.pcs.menu_lvl == "1-2":
self.p_page_index = page
self.p_book_repo = repo
if self.pcs.menu_lvl == "1-3-b":
self.s_page_index = page
self.s_book_repo = repo
if self.pcs.menu_lvl == "1-4-b":
self.c_page_index = page
self.c_book_repo = repo
else:
if self.pcs.menu_lvl == "1-3-b":
self.pcs.menu_lvl = "1-3-e"
else:
self.pcs.menu_lvl = "1-e"
msg = "Error, server replied with" + str(data.status_code)
self.pcs.show_msg(msg)
except Exception as e:
self.userid = None
self.pcs.menu_lvl = "1-e"
exc_type, exc_obj, tb = sys.exc_info()
lineno = tb.tb_lineno
msg = str(e) + str(lineno) #"Network unreachable"
self.pcs.show_msg(msg)
def get_latest_books(self):
try:
if self.l_book_repo == []:
self.fetch_books("latest")
else:
self.menu_lvl = "1-1"
self.book_repo = self.l_book_repo
self.pcs._event.app.editor.focus(self.WINDOW)
self.pcs._event.current_window.buffer._files = self.book_repo
self.pcs._event.current_window.buffer.emit(
EventType.TEXT_CHANGED)
except Exception as e:
self.userid = None
self.pcs.menu_lvl = "1-e"
exc_type, exc_obj, tb = sys.exc_info()
lineno = tb.tb_lineno
msg = str(e) + str(lineno)
self.pcs.show_msg(msg)
def get_popular_books(self):
# Get popular books from bookshare.org
try:
if self.p_book_repo == []:
self.fetch_books("popular")
else:
self.menu_lvl = "1-2"
self.book_repo = self.p_book_repo
self.pcs._event.app.editor.focus(self.WINDOW)
self.pcs._event.current_window.buffer._files = self.book_repo
self.pcs._event.current_window.buffer.emit(
EventType.TEXT_CHANGED)
except Exception as e:
self.userid = None
self.pcs.menu_lvl = "1-e"
exc_type, exc_obj, tb = sys.exc_info()
lineno = tb.tb_lineno
msg = str(e) + str(lineno) #"Network unreachable"
self.pcs.show_msg(msg)
# self.pcs._event.app.editor.error('Network is unreachable')
# def get_popular_books(self):
#
# page=self.latest_page
# try:
# if self.p_book_repo==[]:
# data = requests.get(self.URL + "popularbooks/noOfTimesDelivered/1/startDate/2017-01-01/endDate/2017-12-15/page/"+str(page)+"/limit/17/format/xml?API_key=" + self.KEY, verify=False) # during production remove verify = false
# if(data.status_code == 200):
# parsedData = minidom.parseString(data.text);
# books = parsedData.getElementsByTagName('result')
# if(len(books) == 0):
# # print("No books found")
# pass
# else:
# n=len(books)
# i=0
# for book in books:
# i+=1
# book_index=" ("+str(i)+"/"+str(n)+")"
# row=[]
# for child in book.childNodes:
# if(len(child.childNodes)!=0) and child.tagName != "id":
# row.append(str(child.localName)+":"+str(child.firstChild.nodeValue))
#
# row.append("id:"+str(book.getElementsByTagName('id')[0].firstChild.nodeValue))
# self.p_book_repo.append(row)
#
# else:
# self.pcs.menu_lvl="1-e"
# msg="Error, server replied with"+ str(data.status_code)
# self.pcs.show_msg(msg)
#
# self.book_repo=self.p_book_repo
# self.menu_lvl="1-2"
# self.pcs._event.app.editor.focus(self.WINDOW)
# self.pcs._event.current_window.buffer._files = self.book_repo
# self.pcs._event.current_window.buffer.emit(EventType.TEXT_CHANGED)
# self.latest_page+=1
## if self.pcs._event.current_window.buffer.next_page==True :
## self.pcs._event.app.editor.error("page"+str(self.latest_page))
#
# except Exception as e:
# self.userid=None
# self.pcs.menu_lvl="1-e"
# msg=str(e)#"Network unreachable"
# self.pcs.show_msg(msg)
## self.pcs._event.app.editor.error('Network is unreachable')
#
def _set_input_var(self, *args):
# self.pcs._event.app.editor.error(str(type(args[0])))
if str(args[-1]) == "":
self.get_search_input()
self.search_input = str(args[-1])
self.search_book()
def get_search_input(self):
self.pcs.menu_lvl = "1-3-e"
self.pcs._event.current_window.buffer._files = [["Empty Search"]]
self.pcs._event.current_window.buffer.emit(EventType.TEXT_CHANGED)
self.pcs._event.app.editor.input('search input:',
"PROMPT_WINDOW",
on_ok_handler=self._set_input_var)
def search_book(self):
# Search books by Title/Author from user given user input
search = self.search_input
page = self.s_page_index
self.s_book_repo = self.book_repo
repo = self.s_book_repo
if self.pcs.search_lvl == "1":
url = self.URL + "id/" + search + "/page/" + str(
page) + "/limit/250/format/xml?API_key=" + self.KEY
if self.pcs.search_lvl == "2":
url = self.URL + "title/" + search + "/page/" + str(
page) + "/limit/250/format/xml?API_key=" + self.KEY
if self.pcs.search_lvl == "3":
url = self.URL + "author/" + search + "/page/" + str(
page) + "/limit/250/format/xml?API_key=" + self.KEY
if self.pcs.search_lvl == "4":
url = self.URL + "authortitle/" + search + "/page/" + str(
page) + "/limit/250/format/xml?API_key=" + self.KEY
# if self.pcs.search_lvl=="5":
# url=self.URL + "authortitle/" + search + "/page/"+str(page)+"/limit/250/format/xml?API_key=" + self.KEY
try:
data = requests.get(
url,
verify=False) # during production remove verify = false
if (data.status_code == 200):
parsedData = minidom.parseString(data.text.encode("utf-8"))
books = parsedData.getElementsByTagName('result')
if (len(books) == 0):
s = parsedData.getElementsByTagName("string")
s = s[::-1]
msg = ""
for i in s:
msg = msg + str(i.firstChild.nodeValue) + "."
if not repo == []:
self.pcs.copy_buffer()
self.pcs.menu_lvl = "1-m"
self.pcs.show_msg(msg)
# self.pcs._event.app.editor.focus(self.WINDOW)
# self.pcs._event.current_window.buffer._files = [[msg]]
# self.pcs._event.current_window.buffer.emit(EventType.TEXT_CHANGED)
else:
self.pcs.menu_lvl = "1-3-e"
self.pcs.show_msg(msg)
# self.pcs.bs_choice_selection(self.pcs._event, "1") #bs
# self.pcs._event.app.editor.error('Network is unreachable')
return
else:
self.total_books = parsedData.getElementsByTagName(
'total-results')[0].firstChild.nodeValue
for book in books:
row = []
for child in book.childNodes:
if (len(child.childNodes) != 0
and child.tagName != "id"):
row.append(
str(child.localName) + ":" + str(
child.firstChild.nodeValue.encode(
"utf-8")))
# all_ids.append(book.getElementsByTagName('id')[0].firstChild.nodeValue)
row = row[::-1]
row.append("id:" + str(
book.getElementsByTagName('id')
[0].firstChild.nodeValue))
self.book_repo.append(row)
self.pcs.menu_lvl = "1-3-b"
self.book_repo = self.pcs.insert_book_index(
self.book_repo, self.total_books)
self.s_book_repo = self.book_repo
self.pcs._event.app.editor.focus(self.WINDOW)
self.pcs._event.current_window.buffer._files = self.book_repo
self.pcs._event.current_window.buffer.emit(
EventType.TEXT_CHANGED)
self.pcs.copy_buffer()
page += 1
self.s_page_index = page
else:
self.pcs.menu_lvl = "1-3-e"
msg = "Error server replied with: " + str(data.status_code)
self.pcs.show_msg(msg)
except Exception as e:
self.userid = None
search = ""
self.pcs.menu_lvl = "1-3-e"
exc_type, exc_obj, tb = sys.exc_info()
lineno = tb.tb_lineno
msg = str(e) + str(lineno) #"Network unreachable"
self.pcs.show_msg(msg)
# self.pcs._event.app.editor.error('Network is unreachable')
def get_book_categories(self):
# self.book_repo=[]
page = 1 #self.c_page_index
repo = self.c_book_repo
try:
data = requests.get(
self.URL + "categorylist/page/" + str(page) +
"/limit/52/format/xml?API_key=" + self.KEY,
verify=False) # during production remove verify = false
if (data.status_code == 200):
parsedData = minidom.parseString(data.text.encode("utf-8"))
# xml=parsedData.toxml('utf-8')
categories = parsedData.getElementsByTagName('title')
if (len(categories) == 0):
s = parsedData.getElementsByTagName("string")
s = s[::-1]
msg = ""
for i in s:
msg = msg + str(i.firstChild.nodeValue) + "."
if not repo == []:
self.pcs.copy_buffer()
self.pcs.menu_lvl = "1-m"
self.pcs.show_msg(msg)
# self.pcs._event.app.editor.focus(self.WINDOW)
# self.pcs._event.current_window.buffer._files = [[msg]]
# self.pcs._event.current_window.buffer.emit(EventType.TEXT_CHANGED)
else:
self.pcs.menu_lvl = "1-e"
self.pcs.show_msg(msg)
# self.pcs.bs_choice_selection(self.pcs._event, "1") #bs
# self.pcs._event.app.editor.error('Network is unreachable')
return
else:
self.total_books = parsedData.getElementsByTagName(
'total-results')[0].firstChild.nodeValue
for category in categories:
self.book_repo.append(
[category.firstChild.nodeValue])
self.book_repo = self.pcs.insert_book_index(
self.book_repo, self.total_books)
# self.book_repo.append([self.pcs._event.current_window.buffer.end_msg])
self.pcs._event.app.editor.focus(self.WINDOW)
self.pcs._event.current_window.buffer._files = self.book_repo
# self.pcs._event.current_window.buffer.reset()
self.pcs._event.current_window.buffer.emit(
EventType.TEXT_CHANGED)
self.pcs.menu_lvl = "1-4"
page += 1
self.pcs.copy_buffer()
# self.c_page_index=page
else:
self.pcs.menu_lvl = "1-e"
msg = "Error, server replied with" + str(data.status_code)
self.pcs.show_msg(msg)
except Exception as e:
self.userid = None
self.pcs.menu_lvl = "1-e"
exc_type, exc_obj, tb = sys.exc_info()
lineno = tb.tb_lineno
msg = str(e) + str(lineno) #"Network unreachable"
self.pcs.show_msg(msg)
# self.pcs._event.app.editor.error('Network is unreachable')
def category_book_search(self, category_name):
# self.book_repo=[]
page = self.c_page_index
repo = self.book_repo
try:
data = requests.get(
self.URL + "category/" + category_name + "/page/" +
str(page) + "/limit/250/format/xml?API_key=" + self.KEY,
verify=False)
if (data.status_code == 200):
parsedData = minidom.parseString(data.text.encode("utf-8"))
books = parsedData.getElementsByTagName('result')
# xml=parsedData.toxml('utf-8')
if (len(books) == 0):
s = parsedData.getElementsByTagName("string")
s = s[::-1]
msg = ""
for i in s:
msg = msg + str(i.firstChild.nodeValue) + "."
if not repo == []:
self.pcs.copy_buffer()
self.pcs.menu_lvl = "1-m"
self.pcs.show_msg(msg)
# self.pcs._event.app.editor.focus(self.WINDOW)
# self.pcs._event.current_window.buffer._files = [[msg]]
# self.pcs._event.current_window.buffer.emit(EventType.TEXT_CHANGED)
else:
self.pcs.menu_lvl = "1-e"
self.pcs.show_msg(msg)
# self.pcs.bs_choice_selection(self.pcs._event, "1") #bs
# self.pcs._event.app.editor.error('Network is unreachable')
return
else:
self.total_books = parsedData.getElementsByTagName(
'total-results')[0].firstChild.nodeValue
for book in books:
row = []
for child in book.childNodes:
if (len(child.childNodes) != 0
and child.tagName != "id"):
row.append(
str(child.localName) + ":" +
str(child.firstChild.nodeValue))
# all_ids.append(book.getElementsByTagName('id')[0].firstChild.nodeValue)
row = row[::-1]
row.append("id:" + str(
book.getElementsByTagName('id')
[0].firstChild.nodeValue))
self.book_repo.append(row)
self.book_repo = self.pcs.insert_book_index(
self.book_repo, self.total_books)
self.c_book_repo = self.book_repo
self.pcs._event.app.editor.focus(self.WINDOW)
self.pcs._event.current_window.buffer._files = self.book_repo
self.pcs._event.current_window.buffer.reset()
self.pcs._event.current_window.buffer.emit(
EventType.TEXT_CHANGED)
page += 1
self.c_page_index = page
self.pcs.menu_lvl = "1-4-b"
# self.c_book_repo=self.book_repo
# self.book_repo=self.pcs.insert_book_index(self.book_repo,self.total_books)
# self.pcs._event.app.editor.focus(self.WINDOW)
# self.pcs._event.current_window.buffer._files = self.book_repo
# if page==1:
# self.pcs._event.current_window.buffer.reset()
# self.pcs._event.current_window.buffer.emit(EventType.TEXT_CHANGED)
# page+=1
# self.c_latest_page=page
# self.pcs.menu_lvl="1-4-b"
else:
self.pcs.menu_lvl = "1-e"
msg = "Error, server replied with" + str(data.status_code)
self.pcs.show_msg(msg)
except Exception as e:
self.userid = None
self.pcs.menu_lvl = "1-e"
msg = str(e) #"Network unreachable"
self.pcs.show_msg(msg)
# self.pcs._event.app.editor.error('Network is unreachable')
def get_book_id(self, id):
# Search a particular book by ID
page = self.latest_page
# id=str(id)
try:
data = requests.get(
self.URL + "id/" + str(id) + "/page/" + str(page) +
"/limit/25/format/xml?API_key=" +
self.KEY) # during production remove verify = false
if (data.status_code == 200):
row = []
parsedData = minidom.parseString(data.text)
# xml=parsedData.toxml('utf-8')
try:
msg = parsedData.getElementsByTagName(
'string')[0].firstChild.nodeValue
if msg == "No data existing":
self.pcs.menu_lvl = "1-m"
self.pcs.show_msg(msg)
except:
pass
# title = parsedData.getElementsByTagName('title')[0].firstChild.nodeValue
# author = parsedData.getElementsByTagName('author')[0].firstChild.nodeValue
# synopsis = parsedData.getElementsByTagName('brief-synopsis')[0]
# row.append(title)
# row.append(author)
#
# if(len(synopsis.childNodes) != 0):
# row.append(synopsis.firstChild.nodeValue)
# row.append(id)
#
# self.book_repo=[row]
# self.pcs._event.app.editor.focus(self.WINDOW)
## os.system('clear')
# self.pcs._event.current_window.buffer._files = self.book_repo
# self.pcs._event.current_window.buffer.reset()
# self.pcs._event.current_window.buffer.emit(EventType.TEXT_CHANGED)
else:
self.pcs.menu_lvl = "1-m"
msg = "id not found"
# msg="Error, server replied with "+ str(data.status_code)
self.pcs.show_msg(msg)
except Exception as e:
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
self.userid = None
self.pcs.menu_lvl = "1-e"
msg = "asdawe a af" + str(
exc_tb.tb_lineno) #"Network unreachable"
self.pcs.show_msg(msg)
# self.pcs._event.app.editor.error('Network is unreachable')
def request_book_download(self, id):
def send_request():
page = 1 #self.latest_page
try:
authString = self.userid + ":" + self.password
# authString = "26353" + ':' +"9m85twwz"
encoded = base64.b64encode(bytearray(
authString.encode())).decode()
# print(id)
headers = {
'Authorization': 'Basic ' + encoded,
"page": str(page),
"limit": "1",
"format": "xml",
"API_key": self.KEY,
"bookId": id,
"formatId": '6'
}
data = requests.post(
"https://library.daisyindia.org/NALP/rest/NALPAPIService/raiseBookDownloadRequest",
headers=headers,
verify=False)
if (data.status_code == 200):
parsedData = minidom.parseString(data.text)
if parsedData.getElementsByTagName('message') != []:
message = parsedData.getElementsByTagName(
'message')[0]
self.pcs._event.app.editor.message("request sent")
# self.pcs._event.app.editor.message(str(id))
# self.pcs._event.app.editor.focus(self.WINDOW)
else:
self.pcs._event.app.editor.message(
"Not available to download")
else:
self.pcs.menu_lvl = "1-e"
msg = "Error, server replied with" + str(
data.status_code)
self.pcs.show_msg(msg)
except Exception as e:
self.userid = None
self.pcs.menu_lvl = "1-e"
msg = str(e) #"Network unreachable"
self.pcs.show_msg(msg)
# self.pcs._event.app.editor.error('Network is unreachable')
if self.login_status == False:
self.pcs.next_func = send_request
self.pcs.login.login_process(self.pcs, self.pcs._event, "sp")
else:
send_request()
def get_requested_books(self):
# download books that are ready for downloading
# self.pcs._event.current_window.buffer._files=[["invalid input"]]
# self.pcs._event.current_window.buffer.emit(EventType.TEXT_CHANGED)
## choice="1"
## self.pcs.choice_selection(self.pcs._event, choice)
def get_books():
page = self.latest_page
try:
authString = self.userid + ":" + self.password
# authString = "26353" + ':' "9m85twwz"
encoded = base64.b64encode(bytearray(
authString.encode())).decode()
# print(id)
headers = {
'Authorization': 'Basic ' + encoded,
"page": str(page),
"limit": "10",
"format": "xml",
"API_key": self.KEY
}
data = requests.post(
"https://library.daisyindia.org/NALP/rest/NALPAPIService/fetchUserDownloadRequests",
headers=headers,
verify=False)
if (data.status_code == 200):
parsedData = minidom.parseString(data.text)
# xml=parsedData.toxml('utf-8')
# self.pcs._event.current_window.buffer._files = [[xml]]
# self.pcs._event.current_window.buffer.emit(EventType.TEXT_CHANGED)
# return
count = 1 + (self.latest_page - 1) * 10
books = parsedData.getElementsByTagName('result')
# t = PrettyTable(['ID', 'TITLE', 'STATUS'])
for book in books:
status = book.getElementsByTagName(
'available-to-download'
)[0].firstChild.nodeValue
row = [
str(count),
book.getElementsByTagName('title')
[0].firstChild.nodeValue, status
]
if (status == 'Available for Download'):
self.all_urls[str(
count)] = book.getElementsByTagName(
'downloadUrl')[0].firstChild.nodeValue
count += 1
self.book_repo.append(row)
# print self.book_repo
self.menu_lvl = "1-5"
# os.system('clear')
self.pcs._event.current_window.buffer._files = self.book_repo
# self.pcs._event.app.editor.focus(self.WINDOW)
# os.system('clear')
# self.pcs._event.current_window.buffer.reset()
self.pcs._event.current_window.buffer.emit(
EventType.TEXT_CHANGED)
self.latest_page += 1
self.pcs.copy_buffer()
else:
self.pcs.menu_lvl = "1-e"
msg = "Error, server replied with" + str(
data.status_code)
self.pcs.show_msg(msg)
except Exception as e:
self.userid = None
self.pcs.menu_lvl = "1-e"
msg = str(e) #"Network unreachable"
self.pcs.show_msg(msg)
# self.pcs._event.app.editor.error('Network is unreachable')
if self.login_status == False:
self.pcs.next_func = get_books
self.pcs.login.login_process(self.pcs, self.pcs._event, "sp")
else:
get_books()
def download_book(self, response):
def chdir(dir):
if directory_exists(dir) is False:
# os.makedirs(final_dir)
ftp.mkd(dir)
ftp.cwd(dir)
def directory_exists(dir):
filelist = []
ftp.retrlines('LIST', filelist.append)
for f in filelist:
if f.split()[-1] == dir and f.upper().startswith('D'):
return True
return False
try:
# final_dir=''
import os
current_dir = os.getcwd()
final_dir = os.path.join(current_dir, str(download_folder))
# if not os.path.exists(final_dir):
# os.makedirs(final_dir)
url = self.all_urls[response].split('/')
host = url[2].split(':')[0]
port = url[2].split(':')[1]
filename = url[4]
ftp = ftplib.FTP(host)
ftp.login(self.userid, self.password)
chdir(final_dir)
# try:
# ftp.cwd(final_dir)
# except Exception as e:
# self.pcs._event.app.editor.error('FTP dwD: '+str(e)[0:60])
ftp.retrbinary("RETR " + url[3] + "/" + url[4],
open(filename, 'wb').write)
# ftp.close()
# ftp.quit()
self.pcs._event.app.editor.error('Download completed ' +
str(filename)[0:50])
except KeyError:
self.pcs._event.app.editor.error('queued')
# except Exception as e:
# self.pcs._event.app.editor.error('dwld: '+str(e)[0:50])
except Exception as e:
self.userid = None
msg = str(e) #"Network unreachable"
# self.pcs.show_msg(msg)
self.pcs._event.app.editor.error(msg)
def logout(self):
choice = "1"
self.pcs.choice_selection(self.pcs._event, choice)
if self.login_status == True:
self.login_status = False
self.userid = None
self.password = None
self.pcs._event.app.editor.error(
'logged out of sugamya pustkalay')
else:
self.pcs._event.app.editor.error('already logged out')
except:
_logger.error('application exited with exception: %r' %
traceback.format_exc())
raise
finally:
pass
class Bookshare():
_logger = logger('_login')
try:
# KEY='fh6re3gjwczpyx8f3xfzs8qr'# new 4 july
KEY = os.environ.get(str(bookshare_key))
URL = 'https://api.bookshare.org/book/'
def __init__(self, pcs):
self.pcs = pcs
self.WINDOW = "BOOKLIST_WINDOW"
self.userid = None
self.password = None
self.book_repo = []
self.book_repo_temp = []
self.l_page_index = 1
self.p_page_index = 1
self.s_page_index = 1
self.c_page_index = 1
self._on_search_ok = None
self.search_input = ""
self.all_urls = {}
self.category_name = ""
self.download_threads = []
self.login_status = False
self.l_book_repo = []
self.p_book_repo = []
self.s_book_repo = []
self.c_book_repo = []
self.count = 1 #
self.total_books = "0"
def fetch_books(self, menu):
if menu == "latest":
self.menu_lvl = "1-1"
# choice="1"
page = self.l_page_index
repo = self.l_book_repo
if menu == "popular":
self.menu_lvl = "1-2"
# choice="2"
page = self.p_page_index
repo = self.p_book_repo
# page=415
try:
data = requests.get(
self.URL + menu + "/limit/50/format/xml/page/" +
str(page) + "?api_key=" + self.KEY,
verify=False) # during production remove verify = false
if (data.status_code == 200):
parsedData = minidom.parseString(data.text.encode('utf-8'))
books = parsedData.getElementsByTagName('result')
if (len(books) == 0):
s = parsedData.getElementsByTagName("string")
s = s[::-1]
msg = ""
for i in s:
msg = msg + str(i.firstChild.nodeValue) + "."
if not repo == []:
self.pcs.copy_buffer()
self.pcs.menu_lvl = "1-m"
self.pcs.show_msg(msg)
# self.pcs._event.app.editor.focus(self.WINDOW)
# self.pcs._event.current_window.buffer._files = [[msg]]
# self.pcs._event.current_window.buffer.emit(EventType.TEXT_CHANGED)
else:
self.pcs.menu_lvl = "1-e"
self.pcs.show_msg(msg)
# self.pcs.bs_choice_selection(self.pcs._event, "1") #bs
# self.pcs._event.app.editor.error('Network is unreachable')
return
# pass
else:
# n=len(books)
self.total_books = parsedData.getElementsByTagName(
'string')[0].firstChild.nodeValue.split(
"of")[-1].strip()
# self.num_pages=parsedData.getElementsByTagName('num-pages')[0].firstChild.nodeValue.split("of")[-1].strip()
for i, book in enumerate(books):
# book_index=" ("+str(i+1)+"/"+str(n)+")"
row = []
row.append('author:' + str(
book.getElementsByTagName('author')
[0].firstChild.nodeValue.encode('utf-8')))
row.append('title:' + str(
book.getElementsByTagName('title')
[0].firstChild.nodeValue.encode('utf-8')))
# synopsis = str(book.getElementsByTagName('brief-synopsis')[0].firstChild.nodeValue.encode('utf-8'))
# if(len(synopsis) != 0):
# row.append("synopsis:"+synopsis)
row.append('id:' + str(
book.getElementsByTagName('id')
[0].firstChild.nodeValue.encode('utf-8')))
repo.append(row)
repo = self.pcs.insert_book_index(
repo, self.total_books)
self.book_repo = repo
self.pcs._event.app.editor.focus(self.WINDOW)
self.pcs._event.current_window.buffer._files = self.book_repo
self.pcs._event.current_window.buffer.emit(
EventType.TEXT_CHANGED)
# self.pcs.copy_buffer()
page += 1
if menu == "latest":
self.l_page_index = page
self.l_book_repo = repo
if menu == "popular":
self.p_page_index = page
self.p_book_repo = repo
else:
self.pcs.menu_lvl = "1-e"
msg = "Error, server replied with" + str(data.status_code)
self.pcs.show_msg(msg)
except Exception as e:
self.userid = None
self.pcs.menu_lvl = "1-e"
exc_type, exc_obj, tb = sys.exc_info()
lineno = tb.tb_lineno
msg = str(e) + str(lineno) #"Network unreachable"
self.pcs.show_msg(msg)
def pre_fetch_books(self):
if self.pcs.menu_lvl == "1-1":
menu = "latest"
page = self.l_page_index
repo = self.l_book_repo
url = self.URL + menu + "/limit/100/format/xml/page/" + str(
page) + "?api_key=" + self.KEY
if self.pcs.menu_lvl == "1-2":
menu = "popular"
page = self.p_page_index
repo = self.p_book_repo
url = self.URL + menu + "/limit/100/format/xml/page/" + str(
page) + "?api_key=" + self.KEY
if self.pcs.menu_lvl == "1-3-b":
menu = "search"
search = self.search_input
page = self.s_page_index
repo = self.s_book_repo
# url=self.URL + "search/" + self.search_input + "/limit/250/format/page/" + str(page) + "?api_key=" + self.KEY
if self.pcs.search_lvl == "1":
url = self.URL + "id/" + search + "/limit/250/format/page/" + str(
page) + "?api_key=" + self.KEY
if self.pcs.search_lvl == "2":
url = self.URL + "search/title/" + search + "/limit/250/format/page/" + str(
page) + "?api_key=" + self.KEY
if self.pcs.search_lvl == "3":
url = self.URL + "search/author/" + search + "/limit/250/format/page/" + str(
page) + "?api_key=" + self.KEY
if self.pcs.search_lvl == "4":
url = self.URL + "search/" + search + "/limit/250/format/page/" + str(
page) + "?api_key=" + self.KEY
if self.pcs.search_lvl == "5":
url = self.URL + "searchFTS/" + search + "/limit/250/format/page/" + str(
page) + "?api_key=" + self.KEY
if self.pcs.menu_lvl == "1-4-b":
menu = "book_in_category"
page = self.c_page_index
repo = self.c_book_repo
url = "https://api.bookshare.org/book/search/category/" + self.category_name + "/limit/100/format/page/" + str(
page) + "?api_key=" + self.KEY
tmp_repo = []
self.queued_repo = []
# tmp_repo.append([str(page)])
try:
data = requests.get(
url,
verify=False) # during production remove verify = false
if (data.status_code == 200):
parsedData = minidom.parseString(data.text.encode('utf-8'))
books = parsedData.getElementsByTagName('result')
if (len(books) == 0):
s = parsedData.getElementsByTagName("string")
s = s[::-1]
msg = ""
for i in s:
msg = msg + str(i.firstChild.nodeValue) + "."
if not repo == []:
self.pcs.copy_buffer()
self.pcs.menu_lvl = "1-m"
self.pcs.show_msg(msg)
# self.pcs._event.app.editor.focus(self.WINDOW)
# self.pcs._event.current_window.buffer._files = [[msg]]
# self.pcs._event.current_window.buffer.emit(EventType.TEXT_CHANGED)
else:
if self.pcs.menu_lvl == "1-3-b":
self.pcs.menu_lvl = "1-3-e"
else:
self.pcs.menu_lvl = "1-e"
self.pcs.show_msg(msg)
self.pcs.show_msg(msg)
# self.pcs.bs_choice_selection(self.pcs._event, "1") #bs
# self.pcs._event.app.editor.error('Network is unreachable')
return
else:
self.total_books = parsedData.getElementsByTagName(
'string')[0].firstChild.nodeValue.split(
"of")[-1].strip()
for i, book in enumerate(books):
# book_index=" ("+str(i+1)+"/"+str(n)+")"
row = []
row.append('author:' + str(
book.getElementsByTagName('author')
[0].firstChild.nodeValue.encode('utf-8')))
row.append('title:' + str(
book.getElementsByTagName('title')
[0].firstChild.nodeValue.encode('utf-8')))
# synopsis = str(book.getElementsByTagName('brief-synopsis')[0].firstChild.nodeValue.encode('utf-8'))
# if(len(synopsis) != 0):
# row.append("synopsis:"+synopsis)
row.append('id:' + str(
book.getElementsByTagName('id')
[0].firstChild.nodeValue.encode('utf-8')))
tmp_repo.append(row)
repo = self.pcs.remove_book_index(repo)
tmp_repo = repo + tmp_repo
tmp_repo = self.pcs.insert_book_index(
tmp_repo, self.total_books)
repo = tmp_repo
self.book_repo = repo
self.queued_repo = repo
# self.pcs.copy_buffer()
page += 1
if self.pcs.menu_lvl == "1-1":
self.l_page_index = page
self.l_book_repo = repo
if self.pcs.menu_lvl == "1-2":
self.p_page_index = page
self.p_book_repo = repo
if self.pcs.menu_lvl == "1-3-b":
self.s_page_index = page
self.s_book_repo = repo
if self.pcs.menu_lvl == "1-4-b":
self.c_page_index = page
self.c_book_repo = repo
else:
if self.pcs.menu_lvl == "1-3-b":
self.pcs.menu_lvl = "1-3-e"
else:
self.pcs.menu_lvl = "1-e"
msg = "Error, server replied with" + str(data.status_code)
self.pcs.show_msg(msg)
except Exception as e:
self.userid = None
self.pcs.menu_lvl = "1-e"
exc_type, exc_obj, tb = sys.exc_info()
lineno = tb.tb_lineno
msg = str(e) + str(lineno) #"Network unreachable"
self.pcs.show_msg(msg)
def get_latest_books(self):
# Get latest books from bookshare.org
# self.pcs.copy_buffer()
try:
if self.l_book_repo == []:
self.fetch_books("latest")
else:
self.menu_lvl = "1-1"
self.book_repo = self.l_book_repo
self.pcs._event.app.editor.focus(self.WINDOW)
self.pcs._event.current_window.buffer._files = self.book_repo
self.pcs._event.current_window.buffer.emit(
EventType.TEXT_CHANGED)
except Exception as e:
self.userid = None
self.pcs.menu_lvl = "1-e"
exc_type, exc_obj, tb = sys.exc_info()
lineno = tb.tb_lineno
msg = str(e) + str(lineno) #"Network unreachable"
self.pcs.show_msg(msg)
# self.pcs._event.app.editor.error('Network is unreachable')
def get_popular_books(self):
# Get popular books from bookshare.org
try:
if self.p_book_repo == []:
self.fetch_books("popular")
else:
self.menu_lvl = "1-2"
self.book_repo = self.p_book_repo
self.pcs._event.app.editor.focus(self.WINDOW)
self.pcs._event.current_window.buffer._files = self.book_repo
self.pcs._event.current_window.buffer.emit(
EventType.TEXT_CHANGED)
except Exception as e:
self.userid = None
self.pcs.menu_lvl = "1-e"
exc_type, exc_obj, tb = sys.exc_info()
lineno = tb.tb_lineno
msg = str(e) + str(lineno) #"Network unreachable"
self.pcs.show_msg(msg)
# self.pcs._event.app.editor.error('Network is unreachable')
def _set_input_var(self, *args):
# self.pcs._event.app.editor.error(str(type(args[0])))
self.search_input = str(args[-1])
self.pcs.menu_lvl = "1-3"
self.search_book()
def get_search_input(self):
self.pcs.menu_lvl = "1-3-e"
self.pcs._event.current_window.buffer._files = [["No match found"]]
self.pcs._event.current_window.buffer.emit(EventType.TEXT_CHANGED)
self.pcs._event.app.editor.input('search input:',
"PROMPT_WINDOW",
on_ok_handler=self._set_input_var)
def search_book(self):
# Search books by Title/Author from user given user input
search = self.search_input
page = self.s_page_index
self.s_book_repo = self.book_repo
repo = self.s_book_repo
if self.pcs.search_lvl == "1":
url = self.URL + "id/" + search + "/limit/250/format/page/" + str(
page) + "?api_key=" + self.KEY
if self.pcs.search_lvl == "2":
url = self.URL + "search/title/" + search + "/limit/250/format/page/" + str(
page) + "?api_key=" + self.KEY
if self.pcs.search_lvl == "3":
url = self.URL + "search/author/" + search + "/limit/250/format/page/" + str(
page) + "?api_key=" + self.KEY
if self.pcs.search_lvl == "4":
url = self.URL + "search/" + search + "/limit/250/format/page/" + str(
page) + "?api_key=" + self.KEY
if self.pcs.search_lvl == "5":
url = self.URL + "searchFTS/" + search + "/limit/250/format/page/" + str(
page) + "?api_key=" + self.KEY
try:
data = requests.get(
url,
verify=False) # during production remove verify = false
if (data.status_code == 200):
parsedData = minidom.parseString(data.text.encode("utf-8"))
books = parsedData.getElementsByTagName('result')
if (len(books) == 0):
s = parsedData.getElementsByTagName("string")
s = s[::-1]
msg = ""
for i in s:
msg = msg + str(i.firstChild.nodeValue) + "."
if not repo == []:
self.pcs.copy_buffer()
self.pcs.menu_lvl = "1-m"
self.pcs.show_msg(msg)
# self.pcs._event.app.editor.focus(self.WINDOW)
# self.pcs._event.current_window.buffer._files = [[msg]]
# self.pcs._event.current_window.buffer.emit(EventType.TEXT_CHANGED)
else:
self.pcs.menu_lvl = "1-3-e"
self.pcs.show_msg(msg)
# self.pcs.bs_choice_selection(self.pcs._event, "1") #bs
# self.pcs._event.app.editor.error('Network is unreachable')
return
else:
self.total_books = parsedData.getElementsByTagName(
'string')[0].firstChild.nodeValue.split(
"of")[-1].strip()
for book in books:
row = []
row.append('author:' + str(
book.getElementsByTagName('author')
[0].firstChild.nodeValue.encode('utf-8')))
row.append('title:' + str(
book.getElementsByTagName('title')
[0].firstChild.nodeValue.encode('utf-8')))
# synopsis = str(book.getElementsByTagName('brief-synopsis')[0].firstChild.nodeValue.encode('utf-8'))
# if(len(synopsis) != 0):
# row.append("synopsis:"+synopsis)
row.append('id:' + str(
book.getElementsByTagName('id')
[0].firstChild.nodeValue.encode('utf-8')))
self.book_repo.append(row)
self.pcs.menu_lvl = "1-3-b"
self.s_book_repo = self.book_repo = self.pcs.insert_book_index(
self.book_repo, self.total_books)
self.pcs._event.app.editor.focus(self.WINDOW)
self.pcs._event.current_window.buffer._files = self.book_repo
self.pcs._event.current_window.buffer.emit(
EventType.TEXT_CHANGED)
page += 1
self.s_page_index = page
self.pcs.copy_buffer()
else:
self.pcs.menu_lvl = "1-3-e"
msg = "Error server replied with: " + str(data.status_code)
self.pcs.show_msg(msg)
except Exception as e:
self.userid = None
search = ""
self.pcs.menu_lvl = "1-3-e"
exc_type, exc_obj, tb = sys.exc_info()
lineno = tb.tb_lineno
msg = str(e) + str(lineno) #"Network unreachable"
self.pcs.show_msg(msg)
# self.pcs._event.app.editor.error('Network is unreachable')
def get_book_categories(self):
# self.book_repo=[]
page = 1 #self.c_page_index
repo = self.c_book_repo
try:
data = requests.get(
"https://api.bookshare.org/reference/category/list/limit/250/format/page/"
+ str(page) + "?api_key=" + self.KEY,
verify=False) # during production remove verify = false
if (data.status_code == 200):
parsedData = minidom.parseString(data.text.encode("utf-8"))
# xml=parsedData.toxml('utf-8')
categories = parsedData.getElementsByTagName('name')
# print categories
if (len(categories) == 0):
s = parsedData.getElementsByTagName("string")
s = s[::-1]
msg = ""
for i in s:
msg = msg + str(i.firstChild.nodeValue) + "."
if not repo == []:
self.pcs.copy_buffer()
self.pcs.menu_lvl = "1-m"
self.pcs.show_msg(msg)
# self.pcs._event.app.editor.focus(self.WINDOW)
# self.pcs._event.current_window.buffer._files = [[msg]]
# self.pcs._event.current_window.buffer.emit(EventType.TEXT_CHANGED)
else:
self.pcs.menu_lvl = "1-e"
self.pcs.show_msg(msg)
# self.pcs.bs_choice_selection(self.pcs._event, "1") #bs
# self.pcs._event.app.editor.error('Network is unreachable')
return
else:
# count = 1+(self.latest_page-1)*10
# all_categories = {}
self.total_books = parsedData.getElementsByTagName(
'string')[0].firstChild.nodeValue.split(
"of")[-1].strip()
for category in categories:
self.book_repo.append(
[category.firstChild.nodeValue])
# all_categories[str(count)] = category.firstChild.nodeValue
# count+=1
self.book_repo = self.pcs.insert_book_index(
self.book_repo, self.total_books)
# self.book_repo.append([self.pcs._event.current_window.buffer.end_msg])
self.pcs._event.app.editor.focus(self.WINDOW)
self.pcs._event.current_window.buffer._files = self.book_repo
# self.pcs._event.current_window.buffer.reset()
self.pcs._event.current_window.buffer.emit(
EventType.TEXT_CHANGED)
self.pcs.menu_lvl = "1-4"
page += 1
self.pcs.copy_buffer()
# self.c_page_index=page
else:
self.pcs.menu_lvl = "1-e"
msg = "Error, server replied with" + str(data.status_code)
self.pcs.show_msg(msg)
except Exception as e:
self.userid = None
self.pcs.menu_lvl = "1-e"
exc_type, exc_obj, tb = sys.exc_info()
lineno = tb.tb_lineno
msg = str(e) + str(lineno) #"Network unreachable"
self.pcs.show_msg(msg)
# self.pcs._event.app.editor.error('Network is unreachable')
def category_book_search(self, category_name):
page = self.c_page_index
repo = self.book_repo
try:
# data = requests.get(self.URL + "category/" + category_name + "/format/page/?api_key=" + self.KEY, verify=False)
data = requests.get(
"https://api.bookshare.org/book/search/category/" +
category_name + "/limit/250/format/page/" + str(page) +
"?api_key=" + self.KEY,
verify=False)
if (data.status_code == 200):
parsedData = minidom.parseString(data.text.encode("utf-8"))
xml = parsedData.toxml('utf-8')
books = parsedData.getElementsByTagName('result')
if (len(books) == 0):
# pass
self.pcs._event.app.editor.error(category_name)
return
for i in s:
msg = msg + str(i.firstChild.nodeValue) + "."
if not repo == []:
self.pcs.copy_buffer()
self.pcs.menu_lvl = "1-m"
self.pcs.show_msg(msg)
# self.pcs._event.app.editor.focus(self.WINDOW)
# self.pcs._event.current_window.buffer._files = [[msg]]
# self.pcs._event.current_window.buffer.emit(EventType.TEXT_CHANGED)
else:
self.pcs.menu_lvl = "1-e"
self.pcs.show_msg(msg)
# self.pcs.bs_choice_selection(self.pcs._event, "1") #bs
# self.pcs._event.app.editor.error('Network is unreachable')
return
else:
self.total_books = parsedData.getElementsByTagName(
'string')[0].firstChild.nodeValue.split(
"of")[-1].strip()
for book in books:
row = []
row.append('author:' + str(
book.getElementsByTagName('author')
[0].firstChild.nodeValue.encode('utf-8')))
row.append('title:' + str(
book.getElementsByTagName('title')
[0].firstChild.nodeValue.encode('utf-8')))
# synopsis = str(book.getElementsByTagName('brief-synopsis')[0].firstChild.nodeValue.encode('utf-8'))
# if(len(synopsis) != 0):
# row.append("synopsis:"+synopsis)
row.append('id:' + str(
book.getElementsByTagName('id')
[0].firstChild.nodeValue.encode('utf-8')))
self.book_repo.append(row)
self.book_repo = self.pcs.insert_book_index(
self.book_repo, self.total_books)
self.c_book_repo = self.book_repo
self.pcs._event.app.editor.focus(self.WINDOW)
self.pcs._event.current_window.buffer._files = self.book_repo #[[msg]]# [[xml]]#
self.pcs._event.current_window.buffer.reset()
self.pcs._event.current_window.buffer.emit(
EventType.TEXT_CHANGED)
page += 1
self.c_page_index = page
self.pcs.menu_lvl = "1-4-b"
else:
self.pcs.menu_lvl = "1-e"
msg = "Error, server replied with" + str(data.status_code)
self.pcs.show_msg(msg)
except Exception as e:
self.userid = None
self.category_name = ""
self.pcs.menu_lvl = "1-e"
exc_type, exc_obj, tb = sys.exc_info()
lineno = tb.tb_lineno
msg = str(e) + str(lineno) #"Network unreachable"
self.pcs.show_msg(msg)
# self.pcs._event.app.editor.error('Network is unreachable')
def get_book_id(self, id):
# Search a particular book by ID
try:
data = requests.get(
self.URL + "id/" + str(id) + "/format/xml?api_key=" +
self.KEY,
verify=False) # during production remove verify = false
if (data.status_code == 200):
row = []
parsedData = minidom.parseString(data.text.encode('utf-8'))
# row=[]
# row.append('author:'+str(book.getElementsByTagName('author')[0].firstChild.nodeValue.encode('utf-8')))
# row.append('title:'+str(book.getElementsByTagName('title')[0].firstChild.nodeValue.encode('utf-8')))
## row.append('brief-synopsis:'+str(book.getElementsByTagName('brief-synopsis')[0].firstChild.nodeValue.encode('utf-8')))
# row.append('id:'+str(book.getElementsByTagName('id')[0].firstChild.nodeValue.encode('utf-8')))
# self.book_repo.append(row)
title = 'title:' + str(
book.getElementsByTagName('title')
[0].firstChild.nodeValue.encode('utf-8'))
author = 'author:' + str(
book.getElementsByTagName('author')
[0].firstChild.nodeValue.encode('utf-8'))
synopsis = "synopsis:" + parsedData.getElementsByTagName(
'brief-synopsis')[0].encode('utf-8')
row.append(title)
row.append(author)
if (len(synopsis.childNodes) != 0):
row.append(synopsis.firstChild.nodeValue)
row.append(id)
self.book_repo = [row]
self.pcs._event.app.editor.focus(self.WINDOW)
self.pcs._event.current_window.buffer._files = self.book_repo
self.pcs._event.current_window.buffer.reset()
self.pcs._event.current_window.buffer.emit(
EventType.TEXT_CHANGED)
else:
self.pcs.menu_lvl = "1-e"
msg = "Error, server replied with" + str(data.status_code)
self.pcs.show_msg(msg)
except Exception as e:
self.userid = None
self.pcs.menu_lvl = "1-e"
exc_type, exc_obj, tb = sys.exc_info()
lineno = tb.tb_lineno
msg = str(e) + str(lineno) #"Network unreachable"
self.pcs.show_msg(msg)
# self.pcs._event.app.editor.error('Network is unreachable')
def _on_password_ok(self, *args):
self.password = str(args[-1])
self.pcs._event.current_window.buffer.emit(EventType.TEXT_CHANGED)
# self.pcs.copy_buffer()
# go_to_prev_state
self.pcs._event.app.editor.error("Downloading.")
self.star_download_thread()
def _on_userid_ok(self, *args):
self.userid = str(args[-1])
self.pcs._event.app.editor.input(
'password:'******'userid:',
"PROMPT_WINDOW",
on_ok_handler=self._on_userid_ok)
def book_download(self, id):
# self.userid="vis2alll"
# self.password="******"
if self.count == 1:
id = 1930029
self.count += 1
elif self.count == 2:
id = 1932427
self.count += 1
else:
id = 1930040
self.count = 1
self.book_id = id
if self.userid == None:
self.get_login_credentials()
else:
self.pcs._event.app.editor.error("Downloading...")
self.star_download_thread()
def star_download_thread(self):
t = threading.Thread(target=self.start_download)
t.start()
self.download_threads.append(t)
def start_download(self):
try:
id = self.book_id
m = hashlib.md5(str(self.password)).hexdigest()
data = requests.get(
"https://api.bookshare.org/download/content/" + str(id) +
"/version/1/for/" + str(self.userid) + "?api_key=" +
self.KEY,
headers={"X-password": m},
stream=True) # during production remove verify = false
if data.status_code == 200:
if data.headers.get('content-type') == "application/zip":
current_dir = os.getcwd()
filename = data.headers.get(
"content-disposition").partition("=")[2]
final_dir = os.path.join(
current_dir,
str(download_folder) + str(filename)[:-4])
if not os.path.exists(final_dir):
os.makedirs(final_dir)
import zipfile, StringIO
z = zipfile.ZipFile(StringIO.StringIO(data.content))
z.extractall(final_dir)
# z.extractall()
self.pcs._event.app.editor.error(
'Download completed ' + str(filename)[0:50])
elif data.headers.get('content-type').startswith(
"text/xml"):
self.userid = None
try:
parsedData = minidom.parseString(
data.text.encode('utf-8'))
# sc=parsedData.getElementsByTagName('status-code')[0].firstChild.nodeValue
msg = parsedData.getElementsByTagName('string')
# xml=parsedData.toxml('utf-8')
str_lst = []
for item in msg:
str_lst.append(str(item.firstChild.nodeValue))
self.pcs.menu_lvl = "1-m"
self.pcs.copy_buffer()
self.pcs._event.app.editor.focus(self.WINDOW)
self.pcs._event.current_window.buffer._files = [
str_lst
]
self.pcs._event.current_window.buffer.reset()
self.pcs._event.current_window.buffer.emit(
EventType.TEXT_CHANGED)
# self.pcs.copy_buffer()
except Exception as e:
self.userid = None
self.pcs.menu_lvl = "1-e"
msg = str(e) #"Network unreachable"
self.pcs.show_msg(msg)
# exc_type, exc_obj, exc_tb = sys.exc_info()
# self.pcs._event.app.editor.error("345: "+str(exc_type))
else:
self.userid = None
self.pcs.menu_lvl = "1-e"
msg = str(data.headers.get(
'content-type')) + "content-type not supported."
self.pcs.show_msg(msg)
except Exception as e:
self.userid = None
self.pcs.menu_lvl = "1-e"
exc_type, exc_obj, tb = sys.exc_info()
lineno = tb.tb_lineno
msg = str(e) + str(lineno) #"Network unreachable"
self.pcs._event.app.editor.error(msg)
# self.pcs.show_msg(msg)
def logout(self):
choice = "2"
self.pcs.choice_selection(self.pcs._event, choice)
self.login_status = False
self.userid = None
self.password = None
self.pcs._event.app.editor.error('logged out of bookshare')
except:
_logger.error('application exited with exception: %r' %
traceback.format_exc())
raise
finally:
pass
class process_choice_selection():
try:
_logger = logger('reader-buffer')
def __init__(self, window_name=None):
self._event = None
self.window_name = window_name
self.reader_menu_lst = None
self.lvl = 0
self.menu_lvl = ""
self.sp = None
self.bs = None
self.login_lvl = ""
self.login = _login()
self.menu = ""
self.next_func = None
self.handle = None
self.prev_menu_lvl = None
self.search_lvl = None
self.search_menu_lst = None
# self.prev_total_books=0
def choice_selection(self, _event, choice):
self._event = _event
app = _event.app
choice = str(choice)
if choice == '1':
if self.sp == None:
self.sp = SugamyaPustakalya(self)
#
# if not self.login.login_lvl=="sp":
# self.login.login_process(self,_event,"sp")
# else:
self.menu = "sp"
self.menu_lvl = "1"
lst = [
MenuItem('Latest books', 'l',
lambda app: self.sp_choice_selection(app, '1')),
MenuItem('Popular books', 'p',
lambda app: self.sp_choice_selection(app, '2')),
MenuItem('Search Books by', 's',
lambda app: self.sp_choice_selection(app, '3')),
MenuItem('Book Categories', 'c',
lambda app: self.sp_choice_selection(app, '4')),
MenuItem('Downloads', 'd',
lambda app: self.sp_choice_selection(app, '5')),
MenuItem('Logout', 'x',
lambda app: self.sp_choice_selection(app, 'x')),
MenuItem('Go Back', 'z',
lambda app: self.sp_choice_selection(app, 'b')),
# MenuItem('quits', 'q', lambda app: self.sp_choice_selection(app, 'q'))
]
# if self.login.login_lvl=="sp":
self.get_user_input(app, lst)
# else:
# app.editor.message( 'ELSE,READER in sp: ' )
elif choice == '2':
if self.bs == None:
self.bs = Bookshare(self)
# if not self.login.login_lvl=="bs":
# self.login.login_process(self,_event,"bs")
# else:
self.menu = "bs"
self.menu_lvl = "1"
lst = [
MenuItem('Latest books', 'l',
lambda app: self.bs_choice_selection(app, '1')),
MenuItem('Popular books', 'p',
lambda app: self.bs_choice_selection(app, '2')),
MenuItem('Search Books by', 's',
lambda app: self.bs_choice_selection(app, '3')),
MenuItem('Book Categories', 'c',
lambda app: self.bs_choice_selection(app, '4')),
# MenuItem('Downloads', '5', lambda app: self.bs_choice_selection(app, '5')),
MenuItem('Logout', 'x',
lambda app: self.bs_choice_selection(app, 'x')),
MenuItem('Go Back', 'z',
lambda app: self.bs_choice_selection(app, 'b')),
# MenuItem('quits', 'q', lambda app: self.bs_choice_selection(app, 'q'))
]
# if self.login.login_lvl=="bs":
self.get_user_input(app, lst)
# else:
# app.editor.message( 'ELSE READER in bs menu: ' )
elif choice == '3':
pass
# self.menu_lvl="3"
# app.editor.message('gutenberg ')
elif choice == '4':
pass
# self.menu_lvl="4"
# app.editor.message('local books ')
elif choice == 'q':
def _on_yes(e):
self.menu_lvl = "1"
try:
self.sp = None
self.bs = None
self.login = _login()
# self._event.current_window.buffer._files=[[""]]
self._event.current_window.buffer.reset()
# self._event.current_window.buffer._files=downloaded_files()
self.sp.logout()
except:
pass
try:
self.bs.logout()
except:
pass
def _on_no(e):
self.get_user_input(app, self.reader_menu_lst)
app.editor.confirm('confirm quit?(y/n)',
on_yes_handler=_on_yes,
on_no_handler=_on_no)
else:
app.editor.message('\nInvalid choice.\n ')
def bs_choice_selection(self, app, choice):
self.bs.book_repo = []
if choice == '1':
self.menu_lvl = "1-1"
# self.bs.book_repo=[]
# self.show_msg("opening..")
self.bs.get_latest_books()
elif choice == '2':
self.menu_lvl = "1-2"
# self.bs.book_repo=[]
self.bs.get_popular_books()
elif choice == '3':
self.menu_lvl = "1-3"
# self.bs.book_repo=[]
self.search_menu_lst = [
MenuItem(
'id', '1',
lambda app: self.search_choice_selection(app, '1')),
MenuItem(
'title ', '2',
lambda app: self.search_choice_selection(app, '2')),
MenuItem(
'author', '3',
lambda app: self.search_choice_selection(app, '3')),
MenuItem(
'title/author', '4',
lambda app: self.search_choice_selection(app, '4')),
MenuItem(
'full text search', '5',
lambda app: self.search_choice_selection(app, '5')),
MenuItem(
'back', 'z',
lambda app: self.search_choice_selection(app, 'b')),
]
self.get_user_input(app, self.search_menu_lst)
# self.bs.get_search_input()
elif choice == '4':
self.menu_lvl = "1-4"
# self.bs.book_repo=[]
self.bs.c_page_index = 1
self.bs.get_book_categories()
elif choice == '5':
self.menu_lvl = "1-5"
# self.bs.book_repo=[]
self.all_urls = {}
self.bs.get_requested_books()
elif choice == 'x':
def _on_yes(e):
self.bs.logout()
def _on_no(e):
choice = "2"
self.choice_selection(self._event, choice)
app.editor.confirm('confirm logout?(y/n)',
on_yes_handler=_on_yes,
on_no_handler=_on_no)
elif choice == 'b':
self.menu_lvl = "1"
self.get_user_input(app, self.reader_menu_lst)
elif choice == 'q':
def _on_yes(e):
self.menu_lvl = "1"
try:
self.bs = None
self.login = _login()
# self._event.current_window.buffer._files=[[""]]
self._event.current_window.buffer.reset()
# self._event.current_window.buffer._files=downloaded_files()
self.bs.logout()
except:
pass
def _on_no(e):
choice = "2"
self.choice_selection(self._event, choice)
app.editor.confirm('confirm quit?(y/n)',
on_yes_handler=_on_yes,
on_no_handler=_on_no)
else:
app.editor.message('\nInvalid choice.\n ')
def search_choice_selection(self, app, choice):
handle = None
if self.menu == "sp":
handle = self.sp
mode = "1"
elif self.menu == "bs":
handle = self.bs
mode = "2"
handle.s_book_repo = handle.book_repo = []
if choice == '1':
self.search_lvl = "1"
handle.s_page_index = 1
if choice == '2':
self.search_lvl = "2"
handle.s_page_index = 1
if choice == '3':
self.search_lvl = "3"
handle.s_page_index = 1
if choice == '4':
self.search_lvl = "4"
handle.s_page_index = 1
if choice == '5':
self.search_lvl = "5"
handle.s_page_index = 1
if choice == 'b':
self.menu_lvl = "1-3"
self.choice_selection(self._event, mode)
return
handle.get_search_input()
def sp_choice_selection(self, app, choice):
self.sp.book_repo = []
if choice == '1':
self.menu_lvl = "1-1"
# app.editor.message("fetching books...")
# self.sp.book_repo=[]
self.sp.latest_page = 1
self.sp.get_latest_books()
elif choice == '2':
self.menu_lvl = "1-2"
# app.editor.message('Popular books ')
# self.sp.book_repo=[]
self.sp.latest_page = 1
self.sp.get_popular_books()
elif choice == '3':
self.menu_lvl = "1-3"
# self.bs.book_repo=[]
self.search_menu_lst = [
MenuItem(
'id', '1',
lambda app: self.search_choice_selection(app, '1')),
MenuItem(
'title ', '2',
lambda app: self.search_choice_selection(app, '2')),
MenuItem(
'author', '3',
lambda app: self.search_choice_selection(app, '3')),
MenuItem(
'title/author', '4',
lambda app: self.search_choice_selection(app, '4')),
# MenuItem('full text search', '5', lambda app: self.search_choice_selection(app, '5')),
MenuItem(
'back', 'z',
lambda app: self.search_choice_selection(app, 'b')),
]
self.get_user_input(app, self.search_menu_lst)
elif choice == '4':
self.menu_lvl = "1-4"
# app.editor.message('Book Categories')
# self.sp.book_repo=[]
self.sp.latest_page = 1
self.sp.get_book_categories()
elif choice == '5':
self.menu_lvl = "1-5"
# app.editor.message('Downloads ')
# self.sp.book_repo=[]
self.sp.latest_page = 1
self.all_urls = {}
self.sp.get_requested_books()
elif choice == 'x':
def _on_yes(e):
self.sp.logout()
def _on_no(e):
choice = "1"
self.choice_selection(self._event, choice)
app.editor.confirm('confirm logout?(y/n)',
on_yes_handler=_on_yes,
on_no_handler=_on_no)
elif choice == 'b':
self.menu_lvl = "1"
# app.editor.message('Go Back ')
self.get_user_input(app, self.reader_menu_lst)
elif choice == 'q':
def _on_yes(e):
self.menu_lvl = "1"
try:
self.sp = None
self.login = _login()
self._event.current_window.buffer.reset()
self.sp.logout()
except:
pass
def _on_no(e):
choice = "1"
self.choice_selection(self._event, choice)
app.editor.confirm('confirm quit?(y/n)',
on_yes_handler=_on_yes,
on_no_handler=_on_no)
else:
app.editor.message('\nInvalid choice.\n ')
def copy_buffer(self):
try:
handle = None
if self.menu == "sp":
handle = self.sp
elif self.menu == "bs":
handle = self.bs
buf = self._event.current_window.buffer
buf.prev_lvl = buf.lvl
buf.prev_index = buf.index
buf.prev_files = buf._files
buf.prev_total_books = handle.total_books
self.prev_menu_lvl = self.menu_lvl
except Exception as e:
self._event.app.editor.message(str(e))
def show_msg(self, msg):
try:
if not type(msg) == 'list':
msg = [[msg]]
self._event.current_window.buffer._files = msg
self._event.app.editor.focus(BOOKLIST_WINDOW) #BOOKLIST_WINDOW
self._event.current_window.buffer.reset()
self._event.current_window.buffer.emit(EventType.TEXT_CHANGED)
except Exception as e:
self._event.app.editor.message(str(e))
def remove_book_index(self, repo):
tmp_repo = repo
for i, l in enumerate(repo):
for j, m in enumerate(l):
y = m[::-1].find("(")
tmp_repo[i][j] = m[:-y - 1]
return tmp_repo
def insert_book_index(self, repo, total_books):
n = total_books #len(repo)
for i, l in enumerate(repo):
for j in range(len(l)):
l[j] = l[j] + " (" + str(i + 1) + "/" + str(n) + ")"
return repo
def get_user_input(self, app, lst):
if self.lvl == 0:
self.reader_menu_lst = lst
self.lvl += 1
app.editor.create_menu(self.window_name, lst)
except:
_logger.error('application exited with exception: %r' %
traceback.format_exc())
raise
finally:
pass
