def build(self):
from ia_scribe.tasks.task_scheduler import TaskScheduler
task_scheduler = TaskScheduler()
task_scheduler.start()
app_screen = NetworkTestAppScreen(task_scheduler=task_scheduler, )
return app_screen
def on_start(self):
super(TaskManagerApp, self).on_start()
self.root_window.size = (1000, 600)
self.scheduler = TaskScheduler()
self.scheduler.start()
for task in self.create_dummy_tasks():
self.scheduler.schedule(task)
self.root.attach_scheduler(self.scheduler)
def build(self):
from ia_scribe.tasks.task_scheduler import TaskScheduler
task_scheduler = TaskScheduler()
task_scheduler.start()
from ia_scribe.book.library import Library
library = Library()
app_screen = BookDownloadAppScreen(task_scheduler=task_scheduler,
library=library)
return app_screen
class HeadlessScribe3(object):
def __init__(self, *args, **kwargs):
self.task_scheduler = TaskScheduler()
def queue_task_callback(self, *args, **kwargs):
task = kwargs['task']
path = kwargs['path']
concrete_task = task(path=path)
self.task_scheduler.schedule(concrete_task)
def termination_handler(self, sig, frame):
print('Soft termination: stopping task scheduler and waiting '
'for workers to exit cleanly')
self.task_scheduler.stop()
print('Workers stopped, now exiting')
sys.exit(0)
def run(self):
signal.signal(signal.SIGINT, self.termination_handler)
self.task_scheduler.start()
check_folder_task = FolderMonitor(
periodic=True,
interval=5.0,
queue_task_callback=self.queue_task_callback,
)
self.task_scheduler.schedule(check_folder_task)
while True:
pass
class TaskApp(App):
def __init__(self, **kwargs):
super(TaskApp, self).__init__(**kwargs)
self.scheduler = TaskScheduler()
self.task = self.create_task()
self.task.fbind('on_progress', self._on_task_progress)
self.task.fbind('on_end', self._on_task_end)
def create_task(self):
raise NotImplementedError()
def build(self):
return Builder.load_string(kv)
def on_start(self):
super(TaskApp, self).on_start()
self.scheduler.start()
self.scheduler.schedule(self.task)
def _task_pause_or_resume(self, button):
if button.text == 'Pause':
if self.task.pause():
button.text = 'Resume'
elif button.text == 'Resume':
if self.task.resume():
button.text = 'Pause'
def _task_cancel(self, button):
self.task.cancel()
self.root.ids.buttons.disabled = True
def _on_task_progress(self, task, data):
text = u'{:.0f}% {}'.format(data['progress'] * 100, data['message'])
self.root.ids.label.text = text
self.root.ids.bar.value = data['progress']
def _on_task_end(self, task):
self.root.ids.buttons.disabled = True
def on_stop(self):
super(TaskApp, self).on_stop()
self.task.cancel()
class TaskManagerApp(App):
def build(self):
root = TaskManager(pos_hint={'x': 0.0, 'center_y': 0.5},
size_hint=(1.0, 1.0))
return root
def on_start(self):
super(TaskManagerApp, self).on_start()
self.root_window.size = (1000, 600)
self.scheduler = TaskScheduler()
self.scheduler.start()
for task in self.create_dummy_tasks():
self.scheduler.schedule(task)
self.root.attach_scheduler(self.scheduler)
def on_stop(self):
self.scheduler.stop()
def create_dummy_tasks(self):
out = []
for index in range(1, 16):
task = SimpleTask(name='Task%s' % index,
periodic=index in {1, 2},
interval=5)
out.append(task)
return out
def __init__(self, **kwargs):
super(TaskApp, self).__init__(**kwargs)
self.scheduler = TaskScheduler()
self.task = self.create_task()
self.task.fbind('on_progress', self._on_task_progress)
self.task.fbind('on_end', self._on_task_end)
def __init__(self, *args, **kwargs):
self.task_scheduler = TaskScheduler()
def __init__(self, **kwargs):
self._fullscreen_key_down = False
self.needs_restart = False
self.task_scheduler = TaskScheduler()
super(Scribe3App, self).__init__(**kwargs)
Clock.schedule_once(self._postponed_init, -1)
class Scribe3App(App):
_popups = DictProperty()
def __init__(self, **kwargs):
self._fullscreen_key_down = False
self.needs_restart = False
self.task_scheduler = TaskScheduler()
super(Scribe3App, self).__init__(**kwargs)
Clock.schedule_once(self._postponed_init, -1)
def _postponed_init(self, *args):
self._books_db = Library()
self.update_manager = UpdateManager()
self.update_manager.task_scheduler = self.task_scheduler
self.update_manager.schedule_update_check()
def build(self):
self.title = 'Scribe3 | {}'.format(scribe_globals.BUILD_NUMBER)
self.setup_files()
ExceptionManager.add_handler(RuntimeErrorHandler(self))
return BoxLayout()
def setup_files(self):
self.setup_config_dir()
self.setup_capture_action_config()
self.setup_reshoot_action_config()
self.setup_stats_dirs()
def setup_config_dir(self):
config_dir = scribe_globals.CONFIG_DIR
if not exists(config_dir):
os.makedirs(config_dir)
Logger.debug(
'Scribe3App: Created config dir at {}'.format(config_dir))
def setup_stats_dirs(self):
stats_dirs = [
scribe_globals.STATS_BASE_DIR, scribe_globals.STATS_DIR,
scribe_globals.PROCESSED_STATS_DIR, scribe_globals.METRICS_DIR
]
for stats_dir in stats_dirs:
if not exists(stats_dir):
os.makedirs(stats_dir)
Logger.debug(
'Scribe3App: Created stats dir at {}'.format(stats_dir))
def setup_capture_action_config(self):
version = scribe_globals.CAPTURE_ACTION_BINDINGS_VERSION
current_config = scribe_globals.CAPTURE_ACTION_BINDINGS
default_config = scribe_globals.DEFAULT_CAPTURE_ACTION_BINDINGS
self._setup_action_config(version, current_config, default_config,
CaptureActionDetector)
def setup_reshoot_action_config(self):
version = scribe_globals.RESHOOT_ACTION_BINDINGS_VERSION
current_config = scribe_globals.RESHOOT_ACTION_BINDINGS
default_config = scribe_globals.DEFAULT_RESHOOT_ACTION_BINDINGS
self._setup_action_config(version, current_config, default_config,
ReShootActionDetector)
def _setup_action_config(self, version, current_config, default_config,
detector_cls):
info = Logger.info
if not exists(current_config):
info('Scribe3App: Config {} does not exist'.format(current_config))
shutil.copy(default_config, current_config)
info('Scribe3App: Copied {} -> {}'.format(default_config,
current_config))
else:
detector = detector_cls(current_config, auto_init=False)
detected_version = detector.load_version()
if detected_version != version:
shutil.copy(default_config, current_config)
info('Scribe3App: Config version mismatched. Copied {} -> {}'.
format(default_config, current_config))
info('Scribe3App: Using config from {}'.format(current_config))
def open_settings(self, *largs):
# Prevent F1 press to open Kivy settings
pass
def on_start(self):
window = self.root_window
window.fbind('on_key_down', self._on_key_down)
window.fbind('on_key_up', self._on_key_up)
window.fbind('on_motion', self._on_motion)
window.fbind('on_request_close', self._verify_exit_conditions)
self.root.add_widget(LoadingScreen())
Clock.schedule_once(self._swap_loading_screen_with_root_widget, 1.5)
def _swap_loading_screen_with_root_widget(self, *args):
from ia_scribe.uix.scribe_widget import ScribeWidget
scribe_widget = ScribeWidget(books_db=self._books_db,
task_scheduler=self.task_scheduler)
# scribe_widget.show_user_switch_screen()
self.root.clear_widgets()
self.root.add_widget(scribe_widget)
def on_stop(self):
if EventLoop.status == 'closed':
return
window = self.root_window
window.funbind('on_key_down', self._on_key_down)
window.funbind('on_key_up', self._on_key_up)
window.funbind('on_motion', self._on_motion)
window.funbind('on_request_close', self._verify_exit_conditions)
self.task_scheduler.stop()
def _on_motion(self, *args, **kwargs):
self.root.children[0].refresh_timeout()
def _on_key_down(self,
window,
keycode,
scancode=None,
codepoint=None,
modifiers=None,
**kwargs):
if hasattr(self.root.children[0], 'refresh_timeout'):
self.root.children[0].refresh_timeout()
if scancode == 68 and not self._fullscreen_key_down:
# F11 key is pressed
window.fullscreen = False if window.fullscreen else 'auto'
self._fullscreen_key_down = True
return True
def _on_key_up(self,
window,
keycode,
scancode=None,
codepoint=None,
modifiers=None,
**kwargs):
if scancode == 68 and self._fullscreen_key_down:
self._fullscreen_key_down = False
return True
def _verify_exit_conditions(self, *args):
active_book_workers = [
x for x in self.task_scheduler.get_all_workers()
if x.get('level_name') == 'low' and x.get('task')
]
if not active_book_workers:
return False
self.action = ColoredYesNoActionPopupMixin(
action_function=partial(self.stop, *args),
title='Quit Scribe3?',
message='There are still {} book tasks running.\n'
'Exiting now could [b]botch your uploads[/b].\n\n'
'[b]Exit anyway?[/b]'.format(len(active_book_workers)))
self.action.display()
return True
def get_popup(self, popup_type, **kwargs):
popup = self._popups.pop(popup_type, None)
if popup:
return popup
else:
popup_instance = popup_type(**kwargs)
popup_instance.bind(on_dismiss=self.return_popup)
return popup_instance
def return_popup(self, popup):
self._popups[type(popup)] = popup
def get_screenshot_as_bytes(self):
width, height = size = self.root_window.size
pixels = glReadPixels(0, 0, width, height, GL_RGB, GL_UNSIGNED_BYTE)
image = PIL_Image.frombytes('RGB', size, pixels, 'raw', 'RGB', 0, -1)
fp = BytesIO()
image.save(fp, format='PNG')
fp.seek(0)
return fp.read()
def get_current_screen(self):
if len(self.root.children) > 0:
return self.root.children[0].get_current_screen()
logger = setup_logger()
counter_normal = 0
counter_hiprio = 0
counter_lowprio = 0
durations = [(0, 0, 0)]
def update_receiver(*args, **kwargs):
#print 'received update', args, kwargs
pass
task_scheduler = TaskScheduler()
task_scheduler.start()
time.sleep(1)
def stats_collector(scheduler, storage):
while True:
task_items = scheduler.get_all_tasks()
datapoint = [
time.time(),
len([x for x in task_items if x['task'].state == 'pending']),
len([x for x in task_items if x['task'].state == 'running']),
len([x for x in task_items if x['task'].state == 'done']),
len([
x for x in task_items
if x['level_name'] == 'high' and x['task'].state == 'running'
def load():
from ia_scribe.tasks.task_scheduler import TaskScheduler
task_scheduler = TaskScheduler()
task_scheduler.start()
return True