def runJavaIJapp(memory, appName, args, env=None): env = env or {} getEnviron = Config.getDomain().importFromPlugin('xmipp3', 'Plugin').getEnviron env.update(getEnviron(xmippFirst=False)) # Add scipion variables env[SCIPION_DOMAIN] = Config.SCIPION_DOMAIN env[SCIPION_HOME_VAR]= Config.SCIPION_HOME if Config.debugOn(): env[SCIPION_DEBUG] = "1" # Add out python path to the PATH env["PATH"] = ":".join([sys.executable, env.get("PATH", "")]) # Try chimera try: chimeraPlugin = Config.getDomain().importFromPlugin('chimera', 'Plugin', doRaise=True) env["CHIMERA_LAUNCHER"] = chimeraPlugin.getProgram() + " %s" except Exception as e: pass args = getJavaIJappArguments(memory, appName, args) print('java %s' % args) # return subprocess.Popen('java ' + args, shell=True, env=env) cmd = ['java'] + shlex.split(args) return subprocess.Popen(cmd, env=env)
def main(): program = sys.argv[1] params = ' '.join('"%s"' % x for x in sys.argv[2:]) # Initialize plugin discovery and initialization Config.getDomain().getPlugins() runProgram(program, params)
def _getPlugin(self): if self._plugin is None: try: dirname = self.getDirName() self._plugin = Config.getDomain().getPlugin(dirname) except: pass return self._plugin
def addPluginTemplates(self, tempId=None): """ Get the templates provided by all plugins. :return: a list of templates """ # Check if other plugins have json.templates domain = Config.getDomain() # Check if there is any .json.template in the template folder # get the template folder (we only want it to be included once) for pluginName, pluginModule in domain.getPlugins().items(): tempListPlugin = pluginModule.Plugin.getTemplates() for t in tempListPlugin: if tempId is not None: if t.getObjId() == tempId: self.addTemplate(t) break else: self.addTemplate(t)
def evalParamCondition(self, paramName): """Evaluate if a condition is True for a give param with the values of a particular Protocol""" param = self.getParam(paramName) if not param.hasCondition(): return True condStr = param.condition.get() localDict = {} globalDict = dict(globals()) # FIXME: Check why this import is here from pyworkflow import Config globalDict.update(Config.getDomain().getObjects()) for t in param._conditionParams: if self.hasParam(t) or self._protocol.hasAttribute(t): localDict[t] = self._protocol.getAttributeValue(t) return eval(condStr, globalDict, localDict)
while numParents == 1 and classRef is not Protocol: classRef = classRef.__bases__[0] numParents = len(classRef.__bases__) if numParents > 1: return True else: return False if __name__ == '__main__': count = 0 withDoc = '--with-doc' in sys.argv asciidoc = '--asciidoc' in sys.argv extended = '--extended' in sys.argv emProtocolsDict = Config.getDomain().getProtocols() emCategories = [('Imports', ProtImport, []), ('Micrographs', ProtMicrographs, []), ('Particles', ProtParticles, []), ('2D', Prot2D, []), ('3D', Prot3D, [])] protDict = {} # Group protocols by package name for k, v in emProtocolsDict.items(): packageName = v.getClassPackageName() if packageName not in protDict: protDict[packageName] = [] if not issubclass(v, Viewer) and not v.isBase(): if extended:
else: if len(sys.argv) == 1: # no extra arguments, show current directory showDir(os.getcwd()) else: args = {'-i': []} lastOpt = '-i' for a in sys.argv[1:]: if a.startswith('-'): lastOpt = a if lastOpt not in args: args[lastOpt] = [] else: args[lastOpt].append(a) inputFiles = args['-i'] del args['-i'] viewParams = {} for k, v in args.items(): viewParams[k.replace('-', '')] = ' '.join(v) # Trigger plugin initialization Config.getDomain().getPlugins() for fn in inputFiles: if os.path.isdir(fn): showDir(fn) else: showFile(fn, viewParams)
def main(self, args=None): print("Running tests....") # Trigger plugin's variable definition Config.getDomain().getPlugins() parser = argparse.ArgumentParser(prog=self.getTestsCommand(), description=__doc__) g = parser.add_mutually_exclusive_group() g.add_argument('--run', action='store_true', help='run the selected tests') g.add_argument('--show', action='store_true', help='show available tests', default=True) add = parser.add_argument # shortcut add('--pattern', default='test*.py', help='pattern for the files that will be used in the tests') add('--grep', default=None, nargs='+', help='only show/run tests containing the provided words') add('--skip', default=None, nargs='+', help='skip tests that contains these words') add('--log', default=None, nargs='?', help="Generate logs files with the output of each test.") add('--mode', default='classes', choices=['modules', 'classes', 'onlyclasses', 'all'], help='how much detail to give in show mode') add('tests', metavar='TEST', nargs='*', help='test case from string identifier (module, class or callable)' ) args = parser.parse_args(args) if not args.run and not args.show and not args.tests: sys.exit(parser.format_help()) testsDict = OrderedDict() testLoader = unittest.defaultTestLoader if args.tests: # In this case the tests are passed as argument. # The full name of the test will be used to load it. testsDict['tests'] = unittest.TestSuite() for t in args.tests: try: testsDict['tests'].addTests( testLoader.loadTestsFromName(t)) except Exception as e: print('Cannot load test %s -- skipping' % t) import traceback traceback.print_exc() else: # In this other case, we will load the test available # from pyworkflow and the other plugins # self.paths = [('pyworkflow', os.path.dirname(os.path.dirname(pw.__file__)))] self.paths = [] for name, plugin in pw.Config.getDomain().getPlugins().items(): self.paths.append((name, os.path.dirname(plugin.__path__[0]))) for k, p in self.paths: testPath = os.path.join(p, k, 'tests') if os.path.exists(testPath): testsDict[k] = testLoader.discover(testPath, pattern=args.pattern, top_level_dir=p) self.grep = [g.lower() for g in args.grep] if args.grep else [] self.skip = args.skip self.mode = args.mode self.log = args.log if args.tests: self.runSingleTest(testsDict['tests']) elif args.run: for moduleName, tests in testsDict.items(): print(pwutils.cyan(">>>> %s" % moduleName)) self.runTests(moduleName, tests) elif args.grep: pattern = args.grep[0] for moduleName, tests in testsDict.items(): self.printTests(pattern, tests) else: for moduleName, tests in testsDict.items(): if self._match(moduleName): print(pwutils.cyan(">>>> %s" % moduleName)) self.printTests(moduleName, tests)
def installPluginMethods(): """ Deals with plugin installation methods""" # Trigger plugin's variable definition Config.getDomain().getPlugins() invokeCmd = SCIPION_CMD + " " + sys.argv[1] pluginRepo = PluginRepository() parser = argparse.ArgumentParser( formatter_class=argparse.RawTextHelpFormatter) subparsers = parser.add_subparsers( help='mode "installp", "uninstallp" or "listb"', dest='mode', title='Mode', description='available modes are "installp" or "uninstallp"') ############################################################################ # Install parser # ############################################################################ installParser = subparsers.add_parser( "installp", formatter_class=argparse.RawTextHelpFormatter, usage="%s [-h] [--noBin] [-p pluginName [pipVersion ...]]" % invokeCmd, epilog="Example: %s -p scipion-em-motioncorr 1.0.6 " "-p scipion-em-relion -p scipion-em-eman2 \n\n" % invokeCmd, add_help=False) installParser.add_argument('-h', '--help', action='store_true', help='show help') installParser.add_argument( '--noBin', action='store_true', help='Optional flag to install plugins only as a python module,\n' 'without installing the plugin binaries. This will affect\n' 'all plugins specified in the command.') installParser.add_argument( '--checkUpdates', action='store_true', help='Optional flag to check which plugins have new releases.\n') installParser.add_argument( '-p', '--plugin', action='append', nargs='+', metavar=('pluginName', 'pluginVersion'), help= '- pluginName: the name of the plugin to install from the list\n' ' of available plugins shown below.\n' '- pluginVersion: (optional) pip version to install. If not specified,\n' ' will install the latest compatible with current Scipion.' ) installParser.add_argument( '--devel', action='store_true', help= 'Optional flag to indicate that we will pass install sources instead\n' 'of pip names. Sources might be local paths or git urls. With local\n' 'paths, will do pip install -e (editable mode). It is expected to find\n' 'the plugin name in the basename of the path or in the repo name. \n' '(i.e. it needs to match the one specified in setup.py). E.g:\n' 'scipion installp -p path/to/pluginName --devel \n' 'scipion installp -p https://github.com/someOrg/pluginName.git --devel' ) installParser.add_argument('-j', default='1', metavar='j', help='Number of CPUs to use for compilation \n') ############################################################################ # Uninstall parser # ############################################################################ uninstallParser = subparsers.add_parser( "uninstallp", formatter_class=argparse.RawTextHelpFormatter, usage="%s [-h] [-p pluginName [binVersion ...]]" % invokeCmd, epilog="Example: %s -p scipion-em-eman2 scipion-em-motioncorr \n\n" % invokeCmd, add_help=False) uninstallParser.add_argument('-h', '--help', action='store_true', help='show help') uninstallParser.add_argument( '--noBin', action='store_true', help='Optional flag to uninstall plugins only as a python module,\n' 'without uninstalling the plugin binaries. This will affect\n' 'all plugins specified in the command.') uninstallParser.add_argument( '-p', '--plugin', action='append', metavar='pluginName', help='The name of the plugin to uninstall from the list\n' 'of available plugins shown below.\n') ############################################################################ # Install Bins parser # ############################################################################ installBinParser = subparsers.add_parser( "installb", formatter_class=argparse.RawTextHelpFormatter, usage="%s [-h] binName1 binName2-1.2.3 binName3 ..." % invokeCmd, epilog="Example: %s ctffind4 eman-2.3\n\n" % invokeCmd, add_help=False) # installBinParser.add_argument('pluginName', metavar='pluginName', # help='The name of the plugin whose bins we want to uninstall.\n') installBinParser.add_argument('-h', '--help', action='store_true', help='show help') installBinParser.add_argument( 'binName', nargs='*', metavar='binName(s)', help='The name(s) of the bins we want install, optionally with \n' 'version in the form name-version. If no version is specified,\n' 'will install the last one.') installBinParser.add_argument( '-j', default='1', metavar='j', help='Number of CPUs to use for compilation \n') ############################################################################ # Uninstall Bins parser # ############################################################################ uninstallBinParser = subparsers.add_parser( "uninstallb", formatter_class=argparse.RawTextHelpFormatter, usage="%s [-h] binName1 binName2-1.2.3 binName3 ..." % invokeCmd, epilog="Example: %s ctffind4 relion-3.0\n\n " % invokeCmd, add_help=False) # uninstallBinParser.add_argument('pluginName', metavar='pluginName', # help='The name of the plugin whose bins we want to uninstall.\n') uninstallBinParser.add_argument('-h', '--help', action='store_true', help='show help') uninstallBinParser.add_argument( 'binName', nargs='+', metavar='binName(s)', help='The name(s) of the bins we want to uninstall\n' '(optionally with version in the form name-version). \n' 'If no version is specified, will uninstall the last one.\n') modeToParser = { MODE_INSTALL_BINS: installBinParser, MODE_UNINSTALL_BINS: uninstallBinParser, MODE_INSTALL_PLUGIN: installParser, MODE_UNINSTALL_PLUGIN: uninstallParser } parsedArgs = parser.parse_args(sys.argv[1:]) mode = parsedArgs.mode parserUsed = modeToParser[mode] exitWithErrors = False if parsedArgs.help or (mode in [MODE_INSTALL_BINS, MODE_UNINSTALL_BINS] and len(parsedArgs.binName) == 0): if mode not in [MODE_INSTALL_BINS, MODE_UNINSTALL_BINS]: parserUsed.epilog += pluginRepo.printPluginInfoStr() else: env = Environment() env.setDefault(False) installedPlugins = Config.getDomain().getPlugins() for p, pobj in iteritems(installedPlugins): try: pobj.Plugin.defineBinaries(env) except Exception as e: print( redStr("Error retrieving plugin %s binaries: " % str(p)), e) parserUsed.epilog += env.printHelp() parserUsed.print_help() parserUsed.exit(0) elif mode == MODE_INSTALL_PLUGIN: if parsedArgs.checkUpdates: print(pluginRepo.printPluginInfoStr(withUpdates=True)) installParser.exit(0) if parsedArgs.devel: for p in parsedArgs.plugin: pluginSrc = p[0] pluginName = "" if os.path.exists(pluginSrc): pluginName = os.path.basename( os.path.abspath(pluginSrc).rstrip('/')) else: # we assume it is a git url m = re.match('https://github.com/(.*)/(.*).git', pluginSrc) if m: pluginName = m.group(2) if not pluginName: print("ERROR: Couldn't find pluginName for source %s" % pluginSrc) exitWithErrors = True else: plugin = PluginInfo(pipName=pluginName, pluginSourceUrl=pluginSrc, remote=False) numberProcessor = parsedArgs.j installed = plugin.installPipModule() if installed and not parsedArgs.noBin: plugin.installBin({'args': ['-j', numberProcessor]}) else: pluginsToInstall = list(zip(*parsedArgs.plugin))[0] pluginDict = pluginRepo.getPlugins(pluginList=pluginsToInstall, getPipData=True) if not pluginDict: exitWithErrors = True else: for cmdTarget in parsedArgs.plugin: pluginName = cmdTarget[0] pluginVersion = "" if len(cmdTarget) == 1 else cmdTarget[1] numberProcessor = parsedArgs.j plugin = pluginDict.get(pluginName, None) if plugin: installed = plugin.installPipModule( version=pluginVersion) if installed and not parsedArgs.noBin: plugin.installBin( {'args': ['-j', numberProcessor]}) else: print("WARNING: Plugin %s does not exist." % pluginName) exitWithErrors = True elif parsedArgs.mode == MODE_UNINSTALL_PLUGIN: for pluginName in parsedArgs.plugin: plugin = PluginInfo(pluginName, pluginName, remote=False) if plugin.isInstalled(): if not parsedArgs.noBin: plugin.uninstallBins() plugin.uninstallPip() else: print("WARNING: Plugin %s is not installed." % pluginName) elif parsedArgs.mode == MODE_INSTALL_BINS: binToInstallList = parsedArgs.binName binToPlugin = pluginRepo.getBinToPluginDict() for binTarget in binToInstallList: pluginTargetName = binToPlugin.get(binTarget, None) if pluginTargetName is None: print('ERROR: Could not find target %s' % binTarget) continue pmodule = Config.getDomain().getPlugin(pluginTargetName) numberProcessor = parsedArgs.j pinfo = PluginInfo(name=pluginTargetName, plugin=pmodule, remote=False) pinfo.installBin({'args': [binTarget, '-j', numberProcessor]}) elif parsedArgs.mode == MODE_UNINSTALL_BINS: binToInstallList = parsedArgs.binName binToPlugin = pluginRepo.getBinToPluginDict() for binTarget in binToInstallList: pluginTargetName = binToPlugin.get(binTarget, None) if pluginTargetName is None: print('ERROR: Could not find target %s' % binTarget) continue pmodule = Config.getDomain().getPlugin(pluginTargetName) pinfo = PluginInfo(name=pluginTargetName, plugin=pmodule, remote=False) pinfo.uninstallBins([binTarget]) if exitWithErrors: parserUsed.exit(1) else: parserUsed.exit(0)