Coverage for modules/org/openteacher/profileRunners/rosettaUpdater/rosettaUpdater : 16%

#! /usr/bin/env python3 

# -*- coding: utf-8 -*- 

#       Copyright 2012-2014, 2017, Marten de Vries 

# 

#       This file is part of OpenTeacher. 

# 

#       OpenTeacher is free software: you can redistribute it and/or modify 

#       it under the terms of the GNU General Public License as published by 

#       the Free Software Foundation, either version 3 of the License, or 

#       (at your option) any later version. 

# 

#       OpenTeacher is distributed in the hope that it will be useful, 

#       but WITHOUT ANY WARRANTY; without even the implied warranty of 

#       MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 

#       GNU General Public License for more details. 

# 

#       You should have received a copy of the GNU General Public License 

#       along with OpenTeacher.  If not, see <http://www.gnu.org/licenses/>. 

import os 

import glob 

class RosettaPrioritiesUpdaterModule: 

        def __init__(self, moduleManager, *args, **kwargs): 

                super().__init__(*args, **kwargs) 

                self._mm = moduleManager 

                self.type = "rosettaUpdater" 

                self.priorities = { 

                        "default": -1, 

                        "update-rosetta": 0, 

                } 

                self.requires = ( 

                        self._mm.mods(type="execute"), 

                ) 

        def _getMod(self, template): 

                mapping = {} 

                for mod in self._mm.mods: 

                        modRoot = os.path.dirname(mod.__class__.__file__) 

                        potPathGlob = os.path.join(modRoot, "translations", "*.pot") 

                        potPath = glob.glob(potPathGlob) 

                        if potPath: 

                                potName = os.path.splitext(os.path.basename(potPath[0]))[0].lower() 

                                mapping[potName] = mod 

                                if "_" in potName: 

                                        #second possibility 

                                        mapping[potName.replace("_", "-")] = mod 

                return mapping[template] 

        def _adjustedPriority(self, mod, priority): 

                if mod in self._mm.mods(type="friendlyTranslationNames"): 

                        #this just needs to be on the top of the list. 

                        priority = 10000 

                priorityCorrectionsForKeyword = { 

                        "lesson": 50, 

                        "enterer": 40, 

                        "teacher": 30, 

                        "profiledescription": -40, 

                        "loader": -30, 

                        "saver": -30, 

                        "notecalculator": -70, 

                        "uicontroller": 50, 

                        "mobilegenerator": 15, 

                } 

                for keyword, priorityCorrection in priorityCorrectionsForKeyword.items(): 

                        if keyword in mod.__class__.__file__.lower(): 

                                priority += priorityCorrection 

                return priority 

        def _run(self): 

                answer = input("This updates the priorities and template paths of the translations of OpenTeacher on Launchpad. If you're not in the ~openteachermaintainers team, continuing will probably crash or do nothing. Continue? (y/n) ") 

                if answer.lower() not in ("y", "yes", "yep"): 

                        return 

                lp = launchpadlib.launchpad.Launchpad.login_with("OpenTeacher Rosetta priorities updater", "production") 

                priorities = [] 

                paths = [] 

                for template in lp.projects["openteacher"].translation_focus.getTranslationTemplates(): 

                        if not template.active: 

                                continue 

                        try: 

                                mod = self._getMod(template.name) 

                        except KeyError: 

                                print("Couldn't find a module for: %s" % template.name) 

                                continue 

                        #gather priorities 

                        priority = self._modPriority(mod) 

                        priority = self._adjustedPriority(mod, priority) 

                        priorities.append((priority, template)) 

                        #gather template paths 

                        potPathGlob = os.path.join(os.path.dirname(mod.__class__.__file__), "translations/*.pot") 

                        relPotPathGlob = os.path.relpath(potPathGlob, os.path.join(self._mm.modulesPath, "..")) 

                        templatePath = glob.glob(relPotPathGlob)[0] 

                        paths.append((templatePath, template)) 

                self._savePriorities(sorted(priorities, key=lambda p: p[0])) 

                self._savePaths(sorted(paths, key=lambda p: p[0])) 

        def _savePriorities(self, priorities): 

                for priority, template in priorities: 

                        print("Setting %s priority to %s" % (template.name, priority)) 

                        template.priority = priority 

                        template.lp_save() 

        def _savePaths(self, paths): 

                for path, template in paths: 

                        print("Setting %s path to %s" % (template.name, path)) 

                        template.path = path 

                        template.lp_save() 

        def _calculateModPriority(self, mod): 

                #start priority 

                priority = 1 

                #add the priorities of all mods depending on this one 

                for otherMod in self._mm.mods: 

                        if mod == otherMod: 

                                continue 

                        priority += self._requirementsPriority(mod, otherMod, getattr(otherMod,  "requires", [])) 

                        usesPriority = self._requirementsPriority(mod, otherMod, getattr(otherMod, "uses", [])) 

                        priority += int(round(0.75 * usesPriority)) 

                return priority 

        def _requirementsPriority(self, mod, otherMod, requirements): 

                priority = 0 

                for selector in requirements: 

                        if mod in selector: 

                                priority += self._modPriority(otherMod) 

                return priority 

        def _modPriority(self, mod, cache={}): 

                #caching to speed things up a bit. It's needed. 

                if mod not in cache: 

                        cache[mod] = self._calculateModPriority(mod) 

                return cache[mod] 

        def enable(self): 

                self._modules = next(iter(self._mm.mods(type="modules"))) 

                global launchpadlib 

                try: 

                        import launchpadlib.launchpad 

                except ImportError: 

                        #remain inactive 

                        return 

                self._modules.default("active", type="execute").startRunning.handle(self._run) 

                self.active = True 

        def disable(self): 

                self.active = False 

                self._modules.default("active", type="execute").startRunning.unhandle(self._run) 

                del self._modules 

def init(moduleManager): 

        return RosettaPrioritiesUpdaterModule(moduleManager)