def listen(self):
conf_manager = ConfigurationManager()
config = conf_manager.instance()
detector = hotword_detectors[config['HOTWORD_ENGINE']](
self.detected_callback)
detector.listen()
def create_app(app_name='Is3 Frontend'):
configuration_manager = ConfigurationManager()
app = Flask(app_name)
configure_blueprints(app)
redis_configuration = configuration_manager.get_redis_configuration()
configure_conectors(app, redis_configuration)
return app
def detected_callback():
logger.info('Hotword detected')
player = AudioPlayer()
conf_manager = ConfigurationManager()
config = conf_manager.instance()
player.play(config['DETECT_SOUND'])
recorder = Recorder()
recorded_file = recorder.record()
requester = ProteusRequests()
try:
answer_audio = requester.speech_audio(recorded_file)
except Exception:
logger.error('Connection Error: server unreachable')
return
logger.info('Playing...')
player.play(answer_audio)
def __init__(self, cfg_parser: ConfigurationManager):
super().__init__(cfg_parser, QuantileRegressionAgent.head)
self.cfg = cfg_parser.parse_and_return_dictionary(
"AGENT", QuantileRegressionAgent.required_params)
self.loss = self.build_loss_op()
self.prepare(self.loss)
def __init__(self, cfg_parser: ConfigurationManager, agent: Agent):
act_plcy_cfg = cfg_parser.parse_and_return_dictionary(
"POLICY.EXPLORATION_STRATEGY", Policy.required_params)
if act_plcy_cfg["TYPE"] == "EPSILON_GREEDY":
self.policy = EpsilonGreedy(cfg_parser, agent)
elif act_plcy_cfg["TYPE"] == "SOFTMAX":
self.policy = SoftMax(agent)
else:
raise NotImplementedError
def __init__(self, config_parser: ConfigurationManager,
net: network.GeneralNetwork):
super().__init__(config_parser, net)
self.cfg = config_parser.parse_and_return_dictionary(
"HEAD", SoftmaxFixedAtomsDistributionalHead.required_params)
self.q_dist = tf.nn.softmax(self.q_dist,
name="state_action_value_dist",
axis=-1)
def __init__(self, env: Environment, config_parser: ConfigurationManager):
gym.Wrapper.__init__(self, env.env)
self.cfg = config_parser.parse_and_return_dictionary(
"ENVIRONMENT", NetworkActionToEnvAction.required_params)
if "ACTION_SPECIFICATIONS" in self.cfg:
self.actions = self.cfg["ACTION_SPECIFICATIONS"]
else:
self.actions = list(
range(config_parser.parsed_json["DEFAULT_NUM_ACTIONS"]))
def __init__(self, config_parser: ConfigurationManager):
self.cfg = config_parser.parse_and_return_dictionary(
"ENVIRONMENT", Head.required_params)
if "ACTION_SPECIFICATIONS" in self.cfg:
self.num_actions = len(self.cfg["ACTION_SPECIFICATIONS"])
else:
self.num_actions = config_parser.parsed_json["DEFAULT_NUM_ACTIONS"]
self.greedy_action = None
def __init__(self):
# i18n
languages = []
lc, encoding = locale.getdefaultlocale()
if lc:
languages = [lc]
languages += DEFAULT_LANGUAGES
gettext.bindtextdomain(OCRFEEDER_COMPACT_NAME, LOCALE_DIR)
gettext.textdomain(OCRFEEDER_COMPACT_NAME)
language = gettext.translation(OCRFEEDER_COMPACT_NAME, LOCALE_DIR,
languages = languages, fallback = True)
_ = language.gettext
self.title = OCRFEEDER_STUDIO_NAME
self.main_window = widgetPresenter.MainWindow()
self.main_window.setTitle(self.title)
cli_command_retriever = ArgsRetriever(sys.argv)
imgs = cli_command_retriever.getParams('--images')
self.configuration_manager = ConfigurationManager()
self.ocr_engines_manager = OcrEnginesManager(self.configuration_manager)
self.ocr_engines_manager.makeEnginesFromFolder(self.configuration_manager.user_engines_folder)
self.ocr_engines = self.ocr_engines_manager.ocr_engines
self.configuration_manager.loadConfiguration()
self.source_images_selector = SourceImagesSelector(imgs)
self.source_images_selector.connect('selection_changed', self.selectionChanged)
self.source_images_icon_view = SourceImagesSelectorIconView(self.source_images_selector)
self.source_images_icon_view.setDeleteCurrentPageFunction(self.deleteCurrentPage)
self.source_images_icon_view.show()
self.main_window.main_area_left.add_with_viewport(self.source_images_icon_view)
self.images_selectable_area = {}
self.images_dict = create_images_dict_from_liststore(self.source_images_selector.list_store)
self.source_images_controler = ImageReviewer_Controler(self.main_window.notebook, self.images_dict, self.source_images_icon_view, self.ocr_engines, self.configuration_manager, self.main_window.tripple_statusbar)
self.project_name = None
toolbar_callback_dict = {'detection': self.source_images_controler.performBoxDetection,
'export_to_odt': self.exportToOdt}
menubar_callback_dict = {'exit': self.quit, 'add_image': self.addImage, 'export_to_odt': self.exportToOdt, 'edit_page': self.choosePageSize,
'delete_page': self.deleteCurrentPage, 'export_dialog': self.exportDialog, 'add_folder': self.addFolder,
'import_pdf': self.importPdf, 'save_project': self.saveProject, 'save_project_as': self.saveProjectAs,
'open_project': self.openProject, 'append_project': self.appendProject,'clear': self.clear,
'unpaper': self.unpaper, 'preferences': self.preferences, 'about': self.about,
'ocr_engines': self.ocrEngines, 'zoom_in': self.zoomIn, 'zoom_out': self.zoomOut,
'zoom_fit': self.zoomFit, 'reset_zoom': self.resetZoom}
self.main_window.setHeader(menubar_callback_dict, toolbar_callback_dict)
self.main_window.setDestroyEvent(self.quit)
dirs = cli_command_retriever.getParams('--dir')
if dirs:
self.__addImagesToReviewer(lib.getImagesFromFolder(dirs[0]))
self.main_window.setHasImages(not self.source_images_selector.isEmpty())
def __init__(self, cfg_parser: ConfigurationManager, head):
super().__init__()
from util.util import build_train_and_target_general_network_with_head, get_session
self.sess = get_session(cfg_parser)
self.train_network_base, self.train_network, \
self.target_network_base, self.target_network, self.copy_op, self.saver = \
build_train_and_target_general_network_with_head(head, cfg_parser)
from memory.experience_replay import ExperienceReplay
self.experience_replay = ExperienceReplay(cfg_parser)
self.cfg_parser = cfg_parser
from function_approximator.head import QNetworkHead
self.train_network: QNetworkHead
self.target_network: QNetworkHead
cfg_parser["NUM_ACTIONS"] = self.train_network.num_actions
self.cfg = cfg_parser.parse_and_return_dictionary(
"AGENT", BaseDQNBasedAgent.required_params)
self.train_step = None
self.action_placeholder = tf.placeholder(name="action",
dtype=tf.int32,
shape=[
None,
])
self.reward_placeholder = tf.placeholder(name="reward",
dtype=tf.float32,
shape=(None, ))
# TODO: Optimize memory uint8 -> bool (check if casting works to float)
self.terminal_placeholder = tf.placeholder(name="terminal",
dtype=tf.uint8,
shape=(None, ))
self.predict_calls = 0
self.train_calls = 0
self.num_updates = tf.Variable(initial_value=0,
dtype=tf.int32,
trainable=False)
self.batch_dim_range = tf.range(tf.shape(self.train_network_base.x)[0],
dtype=tf.int32)
self.policy = None
def __init__(self, cfg_parser: ConfigurationManager):
super().__init__(cfg_parser, CategoricalAgent.head)
self.cfg = cfg_parser.parse_and_return_dictionary(
"AGENT", CategoricalAgent.required_params)
self.cfg["NB_ATOMS"] = self.cfg_parser["HEAD.NB_ATOMS"]
self.Z, self.delta_z = np.linspace(self.cfg["V_MIN"],
self.cfg["V_MAX"],
self.cfg["NB_ATOMS"],
retstep=True)
self.loss = self.build_loss_op()
self.prepare(self.loss)
def __init__(self, config_parser: ConfigurationManager):
self.cfg = config_parser.parse_and_return_dictionary(
"NETWORK", GeneralNetwork.required_params)
if "STATE_DIMENSIONS" in self.cfg:
obs_shape = [int(i) for i in self.cfg["STATE_DIMENSIONS"]]
else:
obs_shape = config_parser.parsed_json["DEFAULT_OBS_DIMS"]
# Input
self.x = tf.placeholder(name="state",
dtype=tf.float32,
shape=(None, *obs_shape))
# Convolutional Layers
self.conv_outputs = []
for CONV_LAYER_SPEC in self.cfg["CONVOLUTIONAL_LAYERS_SPEC"]:
self.conv_outputs.append(
layers.conv2d(
name="conv_layer_" + str(len(self.conv_outputs) + 1),
inputs=self.x
if len(self.conv_outputs) == 0 else self.conv_outputs[-1],
filters=CONV_LAYER_SPEC["filters"],
kernel_size=CONV_LAYER_SPEC["kernel_size"],
strides=CONV_LAYER_SPEC["strides"],
activation=tf.nn.relu))
if len(self.cfg["CONVOLUTIONAL_LAYERS_SPEC"]) > 0:
# Flatten
self.flattened_conv_output = tf.layers.flatten(
name="conv_output_flattener", inputs=self.conv_outputs[-1])
last_out = self.flattened_conv_output
else:
last_out = self.x
# Hidden Layer
self.dense_outputs = []
for DENSE_LAYER_SPEC in self.cfg["DENSE_LAYERS_SPEC"]:
self.dense_outputs.append(
layers.dense(
name="fc_layer_" + str(len(self.dense_outputs) + 1),
inputs=last_out if len(
self.dense_outputs) == 0 else self.dense_outputs[-1],
units=DENSE_LAYER_SPEC,
activation=tf.nn.relu))
self.last_op = self.dense_outputs[-1]
def get_session(cfg_params: ConfigurationManager):
required_params = []
tf_params = cfg_params.parse_and_return_dictionary("TENSORFLOW",
required_params)
config = tf.ConfigProto()
if "ALLOW_GPU_GROWTH" not in tf_params or not tf_params["ALLOW_GPU_GROWTH"]:
config.gpu_options.allow_growth = True
if "INTRA_OP_PARALLELISM" in tf_params:
config.intra_op_parallelism_threads = tf_params["INTRA_OP_PARALLELISM"]
if "INTER_OP_PARALLELISM" in tf_params:
config.inter_op_parallelism_threads = tf_params["INTER_OP_PARALLELISM"]
return tf.Session(config=config)
def __init__(self, config_parser: ConfigurationManager,
net: network.GeneralNetwork):
super().__init__(config_parser)
self.cfg = config_parser.parse_and_return_dictionary(
"HEAD", FixedAtomsDistributionalHead.required_params)
# State-Action-Value Distributions (as a flattened vector)
self.flattened_dist = layers.dense(name="flattened_dists",
inputs=net.last_op,
units=self.num_actions *
self.cfg["NB_ATOMS"],
activation=None)
# Unflatten
self.q_dist = tf.reshape(self.flattened_dist,
[-1, self.num_actions, self.cfg["NB_ATOMS"]],
name="per_action_dist")
self.q = tf.reduce_mean(self.q_dist, axis=-1)
self.greedy_action = tf.cast(tf.squeeze(tf.argmax(self.q, axis=-1)),
dtype=tf.int32)
class Studio:
EXPORT_FORMATS = ['HTML', 'ODT']
def __init__(self):
# i18n
languages = []
lc, encoding = locale.getdefaultlocale()
if lc:
languages = [lc]
languages += DEFAULT_LANGUAGES
gettext.bindtextdomain(OCRFEEDER_COMPACT_NAME, LOCALE_DIR)
gettext.textdomain(OCRFEEDER_COMPACT_NAME)
language = gettext.translation(OCRFEEDER_COMPACT_NAME,
LOCALE_DIR,
languages=languages,
fallback=True)
_ = language.gettext
self.title = OCRFEEDER_STUDIO_NAME
self.main_window = widgetPresenter.MainWindow()
self.main_window.setTitle(self.title)
cli_command_retriever = ArgsRetriever(sys.argv)
imgs = cli_command_retriever.getParams('--images')
self.configuration_manager = ConfigurationManager()
self.ocr_engines_manager = OcrEnginesManager(
self.configuration_manager)
self.ocr_engines_manager.makeEnginesFromFolder(
self.configuration_manager.user_engines_folder)
self.ocr_engines = self.ocr_engines_manager.ocr_engines
self.configuration_manager.loadConfiguration()
self.source_images_selector = SourceImagesSelector(imgs)
self.source_images_selector.connect('selection_changed',
self.selectionChanged)
self.source_images_icon_view = SourceImagesSelectorIconView(
self.source_images_selector)
self.source_images_icon_view.setDeleteCurrentPageFunction(
self.deleteCurrentPage)
self.source_images_icon_view.show()
self.main_window.main_area_left.add_with_viewport(
self.source_images_icon_view)
self.images_selectable_area = {}
self.images_dict = create_images_dict_from_liststore(
self.source_images_selector.list_store)
self.source_images_controler = ImageReviewer_Controler(
self.main_window.notebook, self.images_dict,
self.source_images_icon_view, self.ocr_engines,
self.configuration_manager, self.main_window.tripple_statusbar)
self.project_name = None
toolbar_callback_dict = {
'detection': self.source_images_controler.performBoxDetection,
'export_to_odt': self.exportToOdt
}
menubar_callback_dict = {
'exit': self.quit,
'add_image': self.addImage,
'export_to_odt': self.exportToOdt,
'edit_page': self.choosePageSize,
'delete_page': self.deleteCurrentPage,
'export_dialog': self.exportDialog,
'add_folder': self.addFolder,
'import_pdf': self.importPdf,
'save_project': self.saveProject,
'save_project_as': self.saveProjectAs,
'open_project': self.openProject,
'append_project': self.appendProject,
'clear': self.clear,
'unpaper': self.unpaper,
'preferences': self.preferences,
'about': self.about,
'ocr_engines': self.ocrEngines,
'zoom_in': self.zoomIn,
'zoom_out': self.zoomOut,
'zoom_fit': self.zoomFit,
'reset_zoom': self.resetZoom
}
self.main_window.setHeader(menubar_callback_dict,
toolbar_callback_dict)
self.main_window.setDestroyEvent(self.quit)
dirs = cli_command_retriever.getParams('--dir')
if dirs:
self.__addImagesToReviewer(lib.getImagesFromFolder(dirs[0]))
self.main_window.setHasImages(
not self.source_images_selector.isEmpty())
def run(self):
gtk.main()
def addImage(self, widget):
file_open_dialog = widgetPresenter.FileDialog('open',
file_filters=[
(_('Images'),
['image/*'], [])
])
response = file_open_dialog.run()
if response == gtk.RESPONSE_OK:
for file_name in file_open_dialog.get_filenames():
self.__addImagesToReviewer([file_name])
file_open_dialog.destroy()
def importPdf(self, widget):
file_open_dialog = widgetPresenter.FileDialog(
'open', file_filters=[(_('PDF'), ['application/pdf'], [])])
response = file_open_dialog.run()
if response == gtk.RESPONSE_OK:
for file_name in file_open_dialog.get_filenames():
folder = lib.convertPdfToImages(
file_name, self.configuration_manager.getTemporaryDir())
self.__addImagesToReviewer(lib.getImagesFromFolder(folder))
file_open_dialog.destroy()
def addFolder(self, widget):
file_open_dialog = widgetPresenter.FileDialog('select-folder')
response = file_open_dialog.run()
if response == gtk.RESPONSE_OK:
for folder in file_open_dialog.get_filenames():
self.__addImagesToReviewer(lib.getImagesFromFolder(folder))
file_open_dialog.destroy()
def exportToHtml(self, widget=None):
self.source_images_controler.exportPagesToHtml(
self.source_images_selector.getPixbufsSorted())
def exportToOdt(self, widget=None):
self.source_images_controler.exportPagesToOdt(
self.source_images_selector.getPixbufsSorted())
def exportDialog(self, widget):
export_dialog = widgetPresenter.ExportDialog(_('Export pages'),
self.EXPORT_FORMATS)
response = export_dialog.run()
if response == gtk.RESPONSE_ACCEPT:
format = export_dialog.getSelectedFormat().capitalize()
export_dialog.destroy()
exec('self.exportTo%s()' % format)
return None
export_dialog.destroy()
return None
def choosePageSize(self, widget):
self.source_images_controler.choosePageSize()
def deleteCurrentPage(self, widget):
delete_dialog = widgetPresenter.QuestionDialog(
_('Are you sure you want to delete the current image?'))
response = delete_dialog.run()
if response == gtk.RESPONSE_YES:
self.source_images_controler.deleteCurrentPage()
self.source_images_icon_view.deleteCurrentSelection()
delete_dialog.destroy()
def __addImagesToReviewer(self, images):
for image in images:
pixbuf, image, iter = self.source_images_selector.addImage(image)
self.source_images_controler.addImage(pixbuf, image)
tree_path = self.source_images_selector.list_store.get_path(iter)
self.source_images_icon_view.select_path(tree_path)
def setProjectName(self, project_name):
self.project_name = project_name
project_title = os.path.splitext(os.path.basename(
self.project_name))[0]
self.main_window.setTitle('%s - %s' % (self.title, project_title))
def saveProjectAs(self, widget=None):
file_name = self.source_images_controler.saveProjectAs()
if file_name:
self.setProjectName(file_name)
self.saveProject()
def saveProject(self, widget=None):
if self.project_name:
self.source_images_controler.saveProject(self.project_name)
else:
self.saveProjectAs()
def appendProject(self, widget=None):
self.__loadProject(False)
def openProject(self, widget=None):
self.__loadProject()
def __loadProject(self, clear_current=True):
project_title = self.source_images_controler.openProject(clear_current)
if project_title:
self.setProjectName(project_title)
def clear(self, widget=None):
self.source_images_controler.clear()
def unpaper(self, widget=None):
self.source_images_controler.unpaperTool()
def preferences(self, widget=None):
preferences_dialog = widgetPresenter.PreferencesDialog(
self.configuration_manager, self.ocr_engines_manager.ocr_engines)
if preferences_dialog.run() == gtk.RESPONSE_ACCEPT:
preferences_dialog.saveToManager()
self.source_images_controler.updateFromConfiguration()
preferences_dialog.destroy()
def ocrEngines(self, widget=None):
ocr_dialog = widgetPresenter.OcrManagerDialog(self.ocr_engines_manager)
ocr_dialog.run()
ocr_dialog.destroy()
def enginesTool(self, widget=None):
pass
def selectionChanged(self, selector, is_empty):
self.main_window.setHasImages(not is_empty)
def about(self, widget=None):
from gnome import url_show
gtk.about_dialog_set_url_hook(lambda x, y, z: url_show(y), "")
about_dialog = widgetPresenter.CustomAboutDialog()
if about_dialog.run():
about_dialog.destroy()
def zoomIn(self, widget=None):
self.source_images_controler.zoomIn()
def zoomOut(self, widget=None):
self.source_images_controler.zoomOut()
def resetZoom(self, widget=None):
self.source_images_controler.resetZoom()
def zoomFit(self, widget=None):
self.source_images_controler.zoomFit()
def quit(self, widget=None, data=None):
if not self.project_name and not self.source_images_selector.isEmpty():
quit_dialog = widgetPresenter.QuestionDialog(
'<b>' + _("The project hasn't been saved.") + '</b>',
gtk.BUTTONS_NONE)
quit_dialog.format_secondary_text(
_('Do you want to save it before closing?'))
quit_dialog.add_buttons(_('Close anyway'), gtk.RESPONSE_NO,
gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL,
gtk.STOCK_SAVE_AS, gtk.RESPONSE_YES)
response = quit_dialog.run()
quit_dialog.destroy()
if response == gtk.RESPONSE_YES:
self.saveProjectAs()
self.__main_quit()
elif response == gtk.RESPONSE_NO:
quit_dialog.destroy()
self.__main_quit()
else:
self.__main_quit()
def __main_quit(self):
self.configuration_manager.configurationToXml()
gtk.main_quit()
class Studio:
EXPORT_FORMATS = ['HTML', 'ODT']
def __init__(self):
# i18n
languages = []
lc, encoding = locale.getdefaultlocale()
if lc:
languages = [lc]
languages += DEFAULT_LANGUAGES
gettext.bindtextdomain(OCRFEEDER_COMPACT_NAME, LOCALE_DIR)
gettext.textdomain(OCRFEEDER_COMPACT_NAME)
language = gettext.translation(OCRFEEDER_COMPACT_NAME, LOCALE_DIR,
languages = languages, fallback = True)
_ = language.gettext
self.title = OCRFEEDER_STUDIO_NAME
self.main_window = widgetPresenter.MainWindow()
self.main_window.setTitle(self.title)
cli_command_retriever = ArgsRetriever(sys.argv)
imgs = cli_command_retriever.getParams('--images')
self.configuration_manager = ConfigurationManager()
self.ocr_engines_manager = OcrEnginesManager(self.configuration_manager)
self.ocr_engines_manager.makeEnginesFromFolder(self.configuration_manager.user_engines_folder)
self.ocr_engines = self.ocr_engines_manager.ocr_engines
self.configuration_manager.loadConfiguration()
self.source_images_selector = SourceImagesSelector(imgs)
self.source_images_selector.connect('selection_changed', self.selectionChanged)
self.source_images_icon_view = SourceImagesSelectorIconView(self.source_images_selector)
self.source_images_icon_view.setDeleteCurrentPageFunction(self.deleteCurrentPage)
self.source_images_icon_view.show()
self.main_window.main_area_left.add_with_viewport(self.source_images_icon_view)
self.images_selectable_area = {}
self.images_dict = create_images_dict_from_liststore(self.source_images_selector.list_store)
self.source_images_controler = ImageReviewer_Controler(self.main_window.notebook, self.images_dict, self.source_images_icon_view, self.ocr_engines, self.configuration_manager, self.main_window.tripple_statusbar)
self.project_name = None
toolbar_callback_dict = {'detection': self.source_images_controler.performBoxDetection,
'export_to_odt': self.exportToOdt}
menubar_callback_dict = {'exit': self.quit, 'add_image': self.addImage, 'export_to_odt': self.exportToOdt, 'edit_page': self.choosePageSize,
'delete_page': self.deleteCurrentPage, 'export_dialog': self.exportDialog, 'add_folder': self.addFolder,
'import_pdf': self.importPdf, 'save_project': self.saveProject, 'save_project_as': self.saveProjectAs,
'open_project': self.openProject, 'append_project': self.appendProject,'clear': self.clear,
'unpaper': self.unpaper, 'preferences': self.preferences, 'about': self.about,
'ocr_engines': self.ocrEngines, 'zoom_in': self.zoomIn, 'zoom_out': self.zoomOut,
'zoom_fit': self.zoomFit, 'reset_zoom': self.resetZoom}
self.main_window.setHeader(menubar_callback_dict, toolbar_callback_dict)
self.main_window.setDestroyEvent(self.quit)
dirs = cli_command_retriever.getParams('--dir')
if dirs:
self.__addImagesToReviewer(lib.getImagesFromFolder(dirs[0]))
self.main_window.setHasImages(not self.source_images_selector.isEmpty())
def run(self):
gtk.main()
def addImage(self, widget):
file_open_dialog = widgetPresenter.FileDialog('open', file_filters = [(_('Images'), ['image/*'], [])])
response = file_open_dialog.run()
if response == gtk.RESPONSE_OK:
for file_name in file_open_dialog.get_filenames():
self.__addImagesToReviewer([file_name])
file_open_dialog.destroy()
def importPdf(self, widget):
file_open_dialog = widgetPresenter.FileDialog('open', file_filters = [(_('PDF'), ['application/pdf'], [])])
response = file_open_dialog.run()
if response == gtk.RESPONSE_OK:
for file_name in file_open_dialog.get_filenames():
folder = lib.convertPdfToImages(file_name, self.configuration_manager.getTemporaryDir())
self.__addImagesToReviewer(lib.getImagesFromFolder(folder))
file_open_dialog.destroy()
def addFolder(self, widget):
file_open_dialog = widgetPresenter.FileDialog('select-folder')
response = file_open_dialog.run()
if response == gtk.RESPONSE_OK:
for folder in file_open_dialog.get_filenames():
self.__addImagesToReviewer(lib.getImagesFromFolder(folder))
file_open_dialog.destroy()
def exportToHtml(self, widget = None):
self.source_images_controler.exportPagesToHtml(self.source_images_selector.getPixbufsSorted())
def exportToOdt(self, widget = None):
self.source_images_controler.exportPagesToOdt(self.source_images_selector.getPixbufsSorted())
def exportDialog(self, widget):
export_dialog = widgetPresenter.ExportDialog(_('Export pages'), self.EXPORT_FORMATS)
response = export_dialog.run()
if response == gtk.RESPONSE_ACCEPT:
format = export_dialog.getSelectedFormat().capitalize()
export_dialog.destroy()
exec('self.exportTo%s()' % format)
return None
export_dialog.destroy()
return None
def choosePageSize(self, widget):
self.source_images_controler.choosePageSize()
def deleteCurrentPage(self, widget):
delete_dialog = widgetPresenter.QuestionDialog(_('Are you sure you want to delete the current image?'))
response = delete_dialog.run()
if response == gtk.RESPONSE_YES:
self.source_images_controler.deleteCurrentPage()
self.source_images_icon_view.deleteCurrentSelection()
delete_dialog.destroy()
def __addImagesToReviewer(self, images):
for image in images:
pixbuf, image, iter = self.source_images_selector.addImage(image)
self.source_images_controler.addImage(pixbuf, image)
tree_path = self.source_images_selector.list_store.get_path(iter)
self.source_images_icon_view.select_path(tree_path)
def setProjectName(self, project_name):
self.project_name = project_name
project_title = os.path.splitext(os.path.basename(self.project_name))[0]
self.main_window.setTitle('%s - %s' % (self.title, project_title))
def saveProjectAs(self, widget = None):
file_name = self.source_images_controler.saveProjectAs()
if file_name:
self.setProjectName(file_name)
self.saveProject()
def saveProject(self, widget = None):
if self.project_name:
self.source_images_controler.saveProject(self.project_name)
else:
self.saveProjectAs()
def appendProject(self, widget = None):
self.__loadProject(False)
def openProject(self, widget = None):
self.__loadProject()
def __loadProject(self, clear_current = True):
project_title = self.source_images_controler.openProject(clear_current)
if project_title:
self.setProjectName(project_title)
def clear(self, widget = None):
self.source_images_controler.clear()
def unpaper(self, widget = None):
self.source_images_controler.unpaperTool()
def preferences(self, widget = None):
preferences_dialog = widgetPresenter.PreferencesDialog(self.configuration_manager, self.ocr_engines_manager.ocr_engines)
if preferences_dialog.run() == gtk.RESPONSE_ACCEPT:
preferences_dialog.saveToManager()
self.source_images_controler.updateFromConfiguration()
preferences_dialog.destroy()
def ocrEngines(self, widget = None):
ocr_dialog = widgetPresenter.OcrManagerDialog(self.ocr_engines_manager)
ocr_dialog.run()
ocr_dialog.destroy()
def enginesTool(self, widget = None):
pass
def selectionChanged(self, selector, is_empty):
self.main_window.setHasImages(not is_empty)
def about(self, widget = None):
from gnome import url_show
gtk.about_dialog_set_url_hook(lambda x,y,z: url_show(y), "")
about_dialog = widgetPresenter.CustomAboutDialog()
if about_dialog.run():
about_dialog.destroy()
def zoomIn(self, widget = None):
self.source_images_controler.zoomIn()
def zoomOut(self, widget = None):
self.source_images_controler.zoomOut()
def resetZoom(self, widget = None):
self.source_images_controler.resetZoom()
def zoomFit(self, widget = None):
self.source_images_controler.zoomFit()
def quit(self, widget = None, data = None):
if not self.project_name and not self.source_images_selector.isEmpty():
quit_dialog = widgetPresenter.QuestionDialog('<b>' + _("The project hasn't been saved.") + '</b>', gtk.BUTTONS_NONE)
quit_dialog.format_secondary_text(_('Do you want to save it before closing?'))
quit_dialog.add_buttons(_('Close anyway'), gtk.RESPONSE_NO, gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_SAVE_AS, gtk.RESPONSE_YES)
response = quit_dialog.run()
quit_dialog.destroy()
if response == gtk.RESPONSE_YES:
self.saveProjectAs()
self.__main_quit()
elif response == gtk.RESPONSE_NO:
quit_dialog.destroy()
self.__main_quit()
else:
self.__main_quit()
def __main_quit(self):
self.configuration_manager.configurationToXml()
gtk.main_quit()
Receives Configuration File. Propagates to Agent, Memory, Optimizer, Function_Approximator, Environment.
'''
if len(sys.argv) < 2:
raise Exception("Configuration File Required.")
# --- Get Config. File Loc. --- #
from pathlib import Path
parent_dir = Path(__file__).resolve().parent.parent
config_file_loc = parent_dir / "configuration" / sys.argv[1]
# ----------------------------- #
# --- Load Configuration --- #
from configuration import ConfigurationManager
cfg_manager = ConfigurationManager(config_file_loc)
print("Loaded Configuration!")
# -------------------------- #
# --- Create Root Folder --- #
import time
start_time = time.time()
os.makedirs(str(parent_dir / str(start_time)))
cfg_manager["TRAIN_FOLDER"] = str(parent_dir / str(start_time))
print("Created Root Folder: ", str(start_time))
# -------------------------- #
# --- Copy Config. Loc into Root --- #
from shutil import copyfile
copyfile(str(config_file_loc),
str(parent_dir / str(start_time) / "config.json"))
def __init__(self, config_parser: ConfigurationManager,
net: network.GeneralNetwork):
super().__init__(config_parser)
self.cfg = config_parser.parse_and_return_dictionary(
"HEAD", IQNHead.required_params)
self.psi = net.last_op
self.num_samples = tf.placeholder(dtype=tf.int32,
shape=[],
name="num_samples")
# Preprocessed tau (choose number of samples and pass through beta as necessary)
from action_policy.distorted_expectation import distorted_expectation, get_uniform_dist
self.uniform_tau = get_uniform_dist(psi=self.psi,
N_placeholder=self.num_samples)
self.distorted_tau = distorted_expectation(
config_parser, psi=self.psi, N_placeholder=self.num_samples)
import math as m
pi = tf.constant(m.pi)
cos_embed = tf.layers.Dense(units=self.cfg["EMBEDDING_SIZE"],
activation=tf.nn.relu,
name="cosine_embedding")
self.distorted_tau_phi = cos_embed(
tf.cos(
tf.einsum(
'bn,j->bnj', self.distorted_tau,
tf.range(self.cfg["EMBEDDING_SIZE"], dtype=tf.float32)) *
pi))
mul_distorted = tf.einsum('bnj,bj->bnj', self.distorted_tau_phi,
self.psi)
###
self.uniform_tau_phi = cos_embed(
tf.cos(
tf.einsum(
'bn,j->bnj', self.uniform_tau,
tf.range(self.cfg["EMBEDDING_SIZE"], dtype=tf.float32)) *
pi))
mul_uniform = tf.einsum('bnj,bj->bnj', self.uniform_tau_phi, self.psi)
###
q_dist_layer = tf.layers.Dense(units=self.num_actions,
activation=None,
name="q_dist")
self.q_dist = tf.transpose(q_dist_layer(mul_uniform), perm=[0, 2, 1])
self.q_undistorted = tf.reduce_mean(self.q_dist, axis=-1)
self.q_dist_distorted = tf.transpose(q_dist_layer(mul_distorted),
perm=[0, 2, 1])
self.q = tf.reduce_mean(self.q_dist_distorted, axis=-1)
self.greedy_action = tf.cast(tf.squeeze(tf.argmax(self.q, axis=-1)),
dtype=tf.int32)
from sqlalchemy import create_engine from sqlalchemy.ext.declarative import declarative_base from configuration import ConfigurationManager, ConfigProp from .mongodb import MongoManager from .postgres import PostgresManager db_engine = create_engine(ConfigurationManager.get_config_value(ConfigProp.db_postgres_name())) Base = declarative_base()
def __init__(self, config_file=None):
self._config_manager = ConfigurationManager(config_file)
def __init__(self, config_parser: ConfigurationManager):
self.cfg = config_parser.parse_and_return_dictionary(
"EXPERIENCE_REPLAY", ExperienceReplay.required_params)
self.memory = deque(maxlen=self.cfg["EXPERIENCE_REPLAY_SIZE"])
def __init__(self):
# i18n
languages = []
lc, encoding = locale.getdefaultlocale()
if lc:
languages = [lc]
languages += DEFAULT_LANGUAGES
gettext.bindtextdomain(OCRFEEDER_COMPACT_NAME, LOCALE_DIR)
gettext.textdomain(OCRFEEDER_COMPACT_NAME)
language = gettext.translation(OCRFEEDER_COMPACT_NAME,
LOCALE_DIR,
languages=languages,
fallback=True)
_ = language.gettext
self.title = OCRFEEDER_STUDIO_NAME
self.main_window = widgetPresenter.MainWindow()
self.main_window.setTitle(self.title)
cli_command_retriever = ArgsRetriever(sys.argv)
imgs = cli_command_retriever.getParams('--images')
self.configuration_manager = ConfigurationManager()
self.ocr_engines_manager = OcrEnginesManager(
self.configuration_manager)
self.ocr_engines_manager.makeEnginesFromFolder(
self.configuration_manager.user_engines_folder)
self.ocr_engines = self.ocr_engines_manager.ocr_engines
self.configuration_manager.loadConfiguration()
self.source_images_selector = SourceImagesSelector(imgs)
self.source_images_selector.connect('selection_changed',
self.selectionChanged)
self.source_images_icon_view = SourceImagesSelectorIconView(
self.source_images_selector)
self.source_images_icon_view.setDeleteCurrentPageFunction(
self.deleteCurrentPage)
self.source_images_icon_view.show()
self.main_window.main_area_left.add_with_viewport(
self.source_images_icon_view)
self.images_selectable_area = {}
self.images_dict = create_images_dict_from_liststore(
self.source_images_selector.list_store)
self.source_images_controler = ImageReviewer_Controler(
self.main_window.notebook, self.images_dict,
self.source_images_icon_view, self.ocr_engines,
self.configuration_manager, self.main_window.tripple_statusbar)
self.project_name = None
toolbar_callback_dict = {
'detection': self.source_images_controler.performBoxDetection,
'export_to_odt': self.exportToOdt
}
menubar_callback_dict = {
'exit': self.quit,
'add_image': self.addImage,
'export_to_odt': self.exportToOdt,
'edit_page': self.choosePageSize,
'delete_page': self.deleteCurrentPage,
'export_dialog': self.exportDialog,
'add_folder': self.addFolder,
'import_pdf': self.importPdf,
'save_project': self.saveProject,
'save_project_as': self.saveProjectAs,
'open_project': self.openProject,
'append_project': self.appendProject,
'clear': self.clear,
'unpaper': self.unpaper,
'preferences': self.preferences,
'about': self.about,
'ocr_engines': self.ocrEngines,
'zoom_in': self.zoomIn,
'zoom_out': self.zoomOut,
'zoom_fit': self.zoomFit,
'reset_zoom': self.resetZoom
}
self.main_window.setHeader(menubar_callback_dict,
toolbar_callback_dict)
self.main_window.setDestroyEvent(self.quit)
dirs = cli_command_retriever.getParams('--dir')
if dirs:
self.__addImagesToReviewer(lib.getImagesFromFolder(dirs[0]))
self.main_window.setHasImages(
not self.source_images_selector.isEmpty())
import twitter
from configuration import ConfigurationManager
from spotify import SpotifyClient
from messenger import Messenger
configurationManager = ConfigurationManager()
messenger = Messenger()
spotifyClient = SpotifyClient(**configurationManager.getSpotifyConfiguration())
twitterClient = twitter.Api(**configurationManager.getTwitterConfiguration())
print('[Spotify] - Login')
spotifyClient.login()
print('[Spotify] - Login SUCCESS')
print('[Spotify] - Get Currently Playing')
currently_playing_track = spotifyClient.get_currently_playing()
print('[Spotify] - Get Currently Playing SUCCESS')
if currently_playing_track and currently_playing_track['is_playing']:
album = currently_playing_track['item']['album']
artists = currently_playing_track['item']['artists']
message = messenger.create_message(album, artists)
print('[Twitter] - Post message')
twitterClient.PostUpdate(message)
print('[Twitter] - Post message SUCCESS')
