offlate

Julien LepillerSat Nov 14 02:55:26+0100 2020

bfa24fa

Fixes for the callback system

offlate/core/manager.py

                 f.write(json.dumps([]))
     def createProject(self, name, lang, system, data, callback):
         callback.progress(0)
         callback.reportProgress(0)
         projectpath = self.basedir + '/' + name
         path = Path(projectpath)
             rmdir(projectpath)
             return False
         callback.progress(100)
         callback.reportProgress(100)
         self.writeProjects()
         return True

offlate/systems/callback.py

     """
     The base class for callbacks used in the different systems.
     """
     def reportProgress(progress):
     def reportProgress(self, progress):
         """
         Report progress in some operation.  This method is called during download,
         update and upload of translation projects.
         """
         raise Exception("Unimplemented method in concrete class: reportProgress")
     def askPassword(self):
         """
         Get a password (interactively or not) and return it to the caller.
         """
         raise Exception("Unimplemented method in concrete class: askPassword")
     def githubBranchError(branch):
         """
         Report an error while accessing a branch

offlate/systems/git.py

     def transfer_progress(self, stats):
         if self.callback is not None:
             self.callback.progress((100.0 * stats.received_objects) / \
             self.callback.reportProgress((100.0 * stats.received_objects) / \
                     stats.total_objects)
 class GitProject(Project):

offlate/ui/editor.py

 from .spellcheckedit import SpellCheckEdit
 from .tagclickedit import TagClickEdit
 from .parallel import RunnableCallback, RunnableSignals
 from ..systems.callback import SystemCallback
 import math
 import platform
     def __init__(self, parent = None):
         super(ProjectTab, self).__init__(parent)
 class Interface:
 class Interface(SystemCallback):
     def __init__(self):
         self.value = None
     def ok(self):
         self.value = self.qd.textValue()
     def mergeConflict(self, base, oldTranslation, newTranslation):
         # TODO: Actually do something more intelligent
         return newTranslation
     def askPassword(self):
         self.qd = QInputDialog()
         self.qd.setLabelText(self.qd.tr("Please enter your password:"))
         self.qd.exec_()
         return self.value
     def gitlabTokenNotFound(self, server):
     def gitlabTokenNotFoundError(self, server):
         self.qd = QErrorMessage()
         self.qd.showMessage(self.qd.tr("Token for {} not found. Have you added this server to your settings?.").format(server))
         self.qd.exec_()
     def gitlabTokenBranchError(self, branch):
     def gitlabBranchError(self, branch):
         self.qd = QErrorMessage()
         self.qd.showMessage(self.qd.tr("Error while creating branch {}.").format(branch))
         self.qd.exec_()
         self.project.save()
         self.project.send(Interface())
     def askmerge(self, msgid, oldstr, newstr):
         # TODO: Actually do something more intelligent
         return newstr
     def update(self, callback=None):
     def update(self, callback=Interface()):
         self.project.save()
         self.project.update(self.askmerge, callback)
         self.project.update(callback)
         self.content = self.project.content()
         self.updateContent()
         l = self.manager.listProjects()
         for p in l:
             name = p['name']
             act = QAction(name, self)
             act = QAction(name, self)
             act.triggered.connect((lambda name: (lambda : self.open(name)))(name))
             menu.addAction(act)
         self.oldamount = -1
         self.error = None
         self.name = self.widget.project.name
     def run(self):
         self.widget.send()
         self.signals.finished.emit(self.name)
         self.oldamount = -1
         self.error = None
         self.name = self.widget.project.name
     def run(self):
         self.widget.update(self)
         self.widget.update(Interface())
         self.signals.finished.emit(self.name)
 class ExternalRunnable(QRunnable, RunnableCallback):
         self.oldamount = -1
         self.error = None
         self.name = ""
     def run(self):
         # Try to open file with the default application
         try:
             files.extend(f)
         for f in files:
             self.observer.schedule(event_handler, str(Path(f).parent), recursive=True)
     def run(self):
         self.observer.start()
         while self.size > 0:

offlate/ui/parallel.py

 from PyQt5.QtCore import *
 from ..formats.exception import UnsupportedFormatException
 from ..systems.exception import ProjectNotFoundSystemException
 from ..systems.callback import SystemCallback
 class RunnableCallback:
     def progress(self, amount):
 class RunnableCallback(SystemCallback):
     def reportProgress(self, amount):
         if int(round(amount)) > self.oldamount:
             self.oldamount = int(round(amount))
             self.signals.progress.emit(self.name, amount)