Gtk.Application.run() will call this function()
549248
def do_startup(self):
        """"""

        Gtk.Application.do_startup(self)
        gtk_window = Gtk.ApplicationWindow(application=self)
        gtk_window.set_title('AppKit')
        webkit_web_view = WebKit.WebView()
        webkit_web_view.load_uri('http://localhost:' + str(self.port))

        screen = Gdk.Screen.get_default()
        monitor_geometry = screen.get_primary_monitor()
        monitor_geometry = screen.get_monitor_geometry(monitor_geometry)

        settings = webkit_web_view.get_settings()
        settings.set_property('enable-universal-access-from-file-uris', True)
        settings.set_property('enable-file-access-from-file-uris', True)
        settings.set_property('default-encoding', 'utf-8')
        gtk_window.set_default_size(
            monitor_geometry.width * 1.0 / 2.0,
            monitor_geometry.height * 3.0 / 5.0,
        )
        scrollWindow = Gtk.ScrolledWindow()
        scrollWindow.add(webkit_web_view)
        gtk_window.add(scrollWindow)
        gtk_window.connect('delete-event', self._on_gtk_window_destroy)
        webkit_web_view.connect('notify::title', self._on_notify_title)
        self.gtk_window = gtk_window
        self.webkit_web_view = webkit_web_view
        gtk_window.show_all()
230314
function execute() {
  var context = getDefaultContext();
  var compiledOutput = fs.readFileSync(this.outputPath)

  vm.runInContext(compiledOutput, context, this.outputPath);

  var module = extractModule(this.moduleName, context);

  this.compiledModule = context.Elm.fullscreen(module, this.defaults);
}
9317
def main(argv=None):
    '''  '''
    parser = get_parser()

    # Parse arguments and run the function
    global args
    args = parser.parse_args(argv)
    args.func()
1244833
def run():
    
    options = btoptions.Options()
    btlog.initialize_logging(options.log_level, options.log_file)
    app = btapp.get_application()
    app.run()
1374890
def run(self, *args, **kw):
        
        if self._runFunc is not None:
            # remove the two args sent by EditParDialog which we do not use
            if 'mode' in kw: kw.pop('mode')
            if '_save' in kw: kw.pop('_save')
            return self._runFunc(self, *args, **kw)
        else:
            raise taskpars.NoExecError('No way to run task "'+self.__taskName+\
                '". You must either override the "run" method in your '+ \
                'ConfigObjPars subclass, or you must supply a "run" '+ \
                'function in your package.')
859118
def run_function(app_function, event, context):
        
        # getargspec does not support python 3 method with type hints
        # Related issue: https://github.com/Miserlou/Zappa/issues/1452
        if hasattr(inspect, "getfullargspec"):  # Python 3
            args, varargs, keywords, defaults, _, _, _ = inspect.getfullargspec(app_function)
        else:  # Python 2
            args, varargs, keywords, defaults = inspect.getargspec(app_function)
        num_args = len(args)
        if num_args == 0:
            result = app_function(event, context) if varargs else app_function()
        elif num_args == 1:
            result = app_function(event, context) if varargs else app_function(event)
        elif num_args == 2:
            result = app_function(event, context)
        else:
            raise RuntimeError("Function signature is invalid. Expected a function that accepts at most "
                               "2 arguments or varargs.")
        return result
849857
def run(self, f, *args, **kwargs):
        
        parent = _ACTION_CONTEXT.set(self)
        try:
            return f(*args, **kwargs)
        finally:
            _ACTION_CONTEXT.reset(parent)
133289
def run(self, func, *func_args, **func__kwargs):
        
        self._func = func
        self._func_args = func_args
        self._func_kwargs = func__kwargs
        return self
544829
def runUAT(self, args):
		
		Utility.run([self.getRunUATScript()] + args, cwd=self.getEngineRoot(), raiseOnError=True)
301129
async function runProgram() {
    let argvFragment = process.argv.slice(2);
    if (argvFragment.length === 0) {
        argvFragment = ['-h'];
    }

    const latest = await latestVersion(pkg.name, {version: `>${pkg.version}`})
        .catch(() => pkg.version);
    if (semver.gt(latest, pkg.version)) {
        process.stderr.write(chalk.default.white(`\n     Update available `));
        process.stderr.write(chalk.default.grey(`${pkg.version}`));
        process.stderr.write(chalk.default.white(` -> `));
        process.stderr.write(chalk.default.greenBright(`${latest}\n`));
        process.stderr.write(chalk.default.white(`     Run `));
        process.stderr.write(chalk.default.blueBright(`npm i -g ${pkg.name} `));
        process.stderr.write(chalk.default.white(`to update.\n\n`));
    }

    args = minimist(argvFragment);

    if (args.prefix) {
        intercept(function (txt) {
            return `[${pkg.name}]\n${txt}`;
        });
    }

    if (args['!'] ||
        args.help ||
        args.h ||
        args._.includes('help')) {
        return help(args, process.stdout);
    }


    if (args._.length === 1 && args._[0] === 'init') {
        const result = await initializeConfig();
        if (result) {
            await stdoutAsync(`Successfully wrote ${process.cwd()}/.qnamakerrc\n`);
        }
        return;
    }

    if (args.version || args.v) {
        await stdoutAsync(require(path.join(__dirname, '../package.json')).version + '\n');
        return;
    }

    let serviceIn = {};
    if (args.stdin) {
        let json = await stdin();
        serviceIn = JSON.parse(json);
    }

    const config = await composeConfig(args);
    args.kbId = args.kbId || serviceIn.kbId || config.kbId;
    args.subscriptionKey = args.subscriptionKey || serviceIn.subscriptionKey || config.subscriptionKey;
    args.endpointKey = args.endpointKey || serviceIn.endpointKey || config.endpointKey;
    args.hostname = args.hostname || serviceIn.hostname || config.hostname;

    ServiceBase.config = args;

    validateConfig(args);

    if (args._[0] === 'set')
        return await handleSetCommand(args, config);

    const serviceManifest = getServiceManifest(args);

    let requestBody = await validateArguments(serviceManifest);

    // special case operations
    switch (serviceManifest.operation.methodAlias) {
        case 'delete':
            if (!args.f && !args.force) {
                let kbResult = await new Knowledgebase().getKnowledgebaseDetails(config);
                let kb = JSON.parse(await kbResult.text());
                if (!args.force) {
                    let answer = readlineSync.question(`Are you sure you would like to delete ${kb.name} [${kb.id}]? [no] `, {defaultInput: 'no'});
                    if (answer.trim()[0] === 'n') {
                        process.stderr.write('operation canceled');
                        return;
                    }
                }
            }
            break;

        case 'create':
            if (args.name)
                requestBody.name = args.name;

            if (!requestBody.name) {
                if (!(args.q || args.quiet)) {
                    let answer = readlineSync.question(`What would you like to name your new knowledgebase? `);
                    if (answer && answer.length > 0)
                        requestBody.name = answer.trim();
                }
            }
            // hack to map incorrect export property from expected import.  Export uses qnaDocuments, create/update/replace qnaList :(
            if (requestBody.qnaDocuments && !requestBody.qnaList) {
                requestBody.qnaList = requestBody.qnaDocuments;
                delete requestBody.qnaDocuments;
            }
            break;

        case 'replace':
        case 'update':
            // hack to map incorrect export property from expected.  Export uses qnaDocuments, create/update/replace qnaList :(
            if (requestBody.qnaDocuments && !requestBody.qnaList) {
                requestBody.qnaList = requestBody.qnaDocuments;
                delete requestBody.qnaDocuments;
            }
            break;
    }

    let result = await qnamaker(config, serviceManifest, args, requestBody);
    if (result.error) {
        throw new Error(JSON.stringify(result.error, null, 4));
    }

    // special case response
    switch (serviceManifest.operation.name) {
        case 'getKnowledgebaseDetails': {
            config.kbId = result.id;
            let kb = await updateKbId(config);
            if (args.msbot) {
                await stdoutAsync(JSON.stringify({
                    type: 'qna',
                    name: kb.name,
                    id: kb.id,
                    kbId: kb.id,
                    subscriptionKey: config.subscriptionKey,
                    endpointKey: config.endpointKey,
                    hostname: kb.hostName
                }, null, 2) + '\n');
            } else {
                await stdoutAsync(JSON.stringify(result, null, 2) + '\n');
            }
            break;
        }
        case 'createKnowledgebase':
            if (args.wait || args.msbot) {
                result = await waitForOperationSucceeded(config, result);

                let kbId = result.resourceLocation.split('/')[2];
                config.kbId = kbId;
                let kb = await updateKbId(config);
                if (args.msbot) {
                    await stdoutAsync(JSON.stringify({
                        type: 'qna',
                        name: kb.name,
                        id: kb.id,
                        kbId: kb.id,
                        subscriptionKey: config.subscriptionKey,
                        endpointKey: config.endpointKey,
                        hostname: config.hostname
                    }, null, 2) + '\n');

                } else {
                    await stdoutAsync(JSON.stringify(result, null, 2));
                }
                if (args.wait && !(args.q || args.quiet) && !args.msbot) {
                    let answer = readlineSync.question(`Would you like to save ${kb.name} ${kb.id} in your .qnamakerrc so that future commands will be with this KB? [yes] `, {defaultInput: 'yes'});
                    if (answer[0] === 'y') {
                        await fs.writeJson(path.join(process.cwd(), '.qnamakerrc'), config, {spaces: 2});
                        await stdoutAsync('.qnamakerrc updated' + '\n');
                    }
                }
            } else {
                await stdoutAsync(JSON.stringify(result, null, 2));
            }
            break;

        case 'updateKnowledgebase':
            if (args.wait || args.msbot) {
                result = await waitForOperationSucceeded(config, result);
            }
            await stdoutAsync(JSON.stringify(result, null, 2));
            break;

        default: {
            // dump json as json stringified
            if (typeof result === 'string')
                await stdoutAsync(result + '\n');
            else
                await stdoutAsync(JSON.stringify(result, null, 2) + '\n');
            break;
        }
    }
}
135243
def run(self, argv):
        
        (opts, args) = self.parser().parse_args(argv)
        func_args = args[args.index(self.__name__) + 1:]
        func_kwds = opts.__dict__

        return self.__call__(*func_args, **func_kwds)
890586
def execute(global_options,options,arguments) 
      get_action(arguments).call(global_options,options,arguments)
    end
813902
def _run(self):  # pylint: disable=method-hidden
        
        try:
            self.event_stop.wait()
        except gevent.GreenletExit:  # killed without exception
            self.event_stop.set()
            gevent.killall(self.greenlets)  # kill children
            raise  # re-raise to keep killed status
        except Exception:
            self.stop()  # ensure cleanup and wait on subtasks
            raise
316083
function run() {
  var bin = path.resolve(__dirname, '../node_modules/.bin/mocha');
  var args = Array.prototype.slice.call(arguments);
  var fn = args.pop();
  var cmd = [bin].concat(args).join(' ') + ' --no-colors';
  exec(cmd, fn);
}
1329864
def run(self):
        
        with open('src/gvar/__init__.py', 'a') as gvfile:
            gvfile.write("\n__version__ = '%s'\n" % GVAR_VERSION)
        _build_py.run(self)
1056421
def run(self, app):
        """"""
        project_path = os.getcwd()
        if self.args.name is not None:
            project_path = os.path.join(project_path, self.args.name)

        proto_path = paths.PROTO_PATH

        try:
            copytree(proto_path, project_path)
            print(colored('A new glim app created successfully! Happy coding :)', 'green'))
        except FolderExistsError as e:
            print(e)
            print(colored('App already exists', 'red'))
1179612
function run(appName, command, callback) {
    commons.get(format('/%s/apps/%s/run/', deis.version, appName), callback);
  }