How to use mz - 10 common examples

opts[process.argv[i]] = process.argv[i + 1];
}
console.log("Options: ");
console.log(opts);


// Make results directory
if (!fs.existsSync("experiments")) {
  fs.mkdirSync("experiments");
}
fs.mkdirSync(path.join("experiments", opts._id));

// Store source code
fs.writeFileSync(path.join("experiments", opts._id, "source_code.js"), fs.readFileSync("./rand.js"));
// Store image
fs.writeFileSync(path.join("experiments", opts._id, "mnist.png"), fs.readFileSync("./mnist.png"));
// Store custom fields
fs.writeFileSync(path.join("experiments", opts._id, "notes.json"), JSON.stringify({"Notes": "This field is being used to store notes about the experiment.", "Version": "Node.js " + process.version}));


// Creates a linear scale
var linScale = function(numEls, step, start) {
  return _.map(Array(numEls), (val, ind) => {
    return start + step*ind;
  });
};

// Creates an exponential decay curve with noise
var noisyExp = function(val, ind, coll) {
  var exp = Math.pow(0.9, ind/coll.length) - 0.9;
  return exp + exp*Math.random();
};

assertDependenciesEqual: function assertDependenciesEqual (outputDir, debFilename, userDependencies) {
    const dpkgDebCmd = `dpkg-deb -f ${debFilename} Depends Recommends Suggests Enhances Pre-Depends`
    return exec(dpkgDebCmd, { cwd: outputDir })
      .then(stdout => {
        const baseDependencies = {
          Depends: _.sortBy(_.union(defaults.depends, userDependencies.depends)),
          Recommends: _.sortBy(_.union(defaults.recommends, userDependencies.recommends)),
          Suggests: _.sortBy(_.union(defaults.suggests, userDependencies.suggests)),
          Enhances: _.sortBy(_.union(defaults.enhances, userDependencies.enhances)),
          'Pre-Depends': _.sortBy(_.union(defaults.preDepends, userDependencies.preDepends))
        } // object with both user and default dependencies based on src/installer.js

        // Creates object based on stdout (values are still strings)
        let destDependencies = _.fromPairs(_.chunk(_.initial(stdout.toString().split(/\n|:\s/)), 2))
        // String values are mapped into sorted arrays
        destDependencies = _.mapValues(destDependencies, function (value) {
          if (value) return _.sortBy(value.split(', '))
        })

test.serial("method `upgrade` runs only new migrations", async (t) => {
  let count = 0;
  let migrator = new Migrator({ cacheFilePath });

  await fs.writeFile(cacheFilePath, 1); // migration index=1 has already been executed

  migrator.add({
    index: 1,
    upgrade: () => count++,
  });
  migrator.add({
    index: 3,
    upgrade: () => count++,
  });

  let index = await migrator.upgrade();

  t.is(count, 1);
  t.is(index, 3);
});

async function importFromGit({
    db,
    repo,
    branch = 'master',
    tmpDir = `${dir}/tmp`,
    checkout,
}) {
    if (!(await fs.exists(dir))) {
        await fs.mkdir(dir);
    }

    console.log(chalk.yellow('Starting mongodb import'));

    console.log(chalk.cyan('Cleaning up (in case of errors)'));

    await run(`rm -rf ${tmpDir}`);

    console.log(chalk.cyan('Cloning backup repository'));

    try {
        await run(`eval \`ssh-agent -s\` &&
        ssh-add ~/.ssh/id_rsa`);
    } catch (e) {} // eslint-disable-line no-empty

if (file.name === 'readme') {
      fileContent = Buffer.from(`# ${github.repoName.split('/')[1]}

TODO This needs to be filled out!`)

      console.robowarn('You need to fill out the README manually!')

      file.content = fileContent.toString('base64')
    } else {
      if (file.name === 'contributing' && opts.contributing) {
        fileContent = await fs.readFileSync(path.join(__dirname, '../../', opts.contributing)).toString('utf8')
      } else {
        const {data} = await github.get(`/repos/${github.repoName}/readme`)
        const readme = Buffer.from(data.content, 'base64')
        const filePath = path.join(__dirname, '..', '..', 'fixtures', file.filePath)
        fileContent = getSection(readme, 'contribute') || await fs.readFileSync(filePath, 'utf8')
      }

      // Text Replacements
      if (file.name === 'code_of_conduct') {
        fileContent = fileContent.replace('[INSERT EMAIL ADDRESS]', email)
        file.note.push(`Check the email in the Code of Conduct. We've added in "${email}".`)
      } else if (file.name === 'license') {
        fileContent = fileContent.replace('[INSERT LICENSEE]', licensee)
        file.note.push(`Check the licensee in the License. We've licensed this to "${licensee}".`)
      } else if (file.name === 'contributing') {
        fileContent = fileContent.replace('[GITHUB REPONAME]', github.repoName)
      }

      file.content = btoa(fileContent)
    }

let tmp = str.split('_');
        for (let i = 0; i < tmp.length; i++) {
          if (i > 0 || type == 'ucfirst') {
            name += tmp[i].charAt(0).toUpperCase() + tmp[i].slice(1);
          } else {
            name += tmp[i];
          }
        }
        return name;
      });

      // write file Router.ts in OUTPUT_DIR/router/
      let routerContent = TplEngine.render('router/router', {
        infos: gatewayInfoList,
      });
      await LibFs.writeFile(LibPath.join(OUTPUT_DIR, 'router', 'Router.ts'), routerContent);

      // write file RouterAPITest.ts in OUTPUT_DIR/router/
      let testContent = TplEngine.render('router/test', {
        infos: gatewayInfoList,
      });
      await LibFs.writeFile(LibPath.join(OUTPUT_DIR, 'router', 'RouterAPITest.ts'), testContent);

      // write file ${gatewayApiName}.ts in OUTPUT_DIR/router/${gatewayApiService}/
      for (let gatewayInfo of gatewayInfoList) {
        const relativePath = this._protoMsgImportInfos[`${gatewayInfo.packageName}${gatewayInfo.serviceName}`].protoFile.relativePath;
        await mkdir(LibPath.join(OUTPUT_DIR, 'router', relativePath, gatewayInfo.serviceName));

        let apiContent = TplEngine.render('router/api', {
          info: gatewayInfo,
        });

async function main(): Promise {
  // Linting sub-projects requires the latest Sucrase types, so require a build first.
  if (!(await exists("./dist"))) {
    console.log("Must run build before lint, running build...");
    await run("yarn build");
  }
  await Promise.all([
    checkSucrase(),
    checkProject("./integrations/gulp-plugin"),
    checkProject("./integrations/jest-plugin"),
    checkProject("./integrations/webpack-loader"),
    checkProject("./integrations/webpack-object-rest-spread-plugin"),
    checkProject("./website"),
  ]);
}

console.log(`Cloning ${options.repoUrl} #${branch} to ${sourceDir}...`);
    await fs.ensureDir(fixturesDir);
    await fs.remove(sourceDir);

    await exec(
        `git clone ${options.repoUrl} ${sourceDir} --branch=${
            branch} --depth=1`,
        {cwd: fixturesDir});
    await fs.remove(path.join(sourceDir, '.git'));
    await fs.remove(path.join(sourceDir, '.github'));
    await fs.remove(path.join(sourceDir, '.gitignore'));

    await overridePolymer(sourceDir);

    await exec('bower install', {cwd: sourceDir});
  }

  const testConfig = require(path.join(fixturesDir, 'test.js')) as TestConfig;
  await runFixture(sourceDir, convertedDir, testConfig);

  // Our integration tests always skip bower_components when comparing, so
  // there's no reason to check them into git.
  await fs.remove(path.join(convertedDir, 'bower_components'));

  console.log(`Done.`);
}

export async function nativeRun(opts) {
  const path = opts.mobileapp || await getAppDir(opts.appId);

  await syncApp(path, opts);

  const packagerPromise = startPackager(path, { resolveOnReady: true });

  try {
    const runResult = await platform.runPlatform(path, opts);
    const output = runResult.stdout + runResult.stderr;

    if (output.indexOf('Code signing is required for product type') > 0) {
      let xcodeProjectPath = join(path, 'ios', 'ShoutemApp.xcworkspace');
      console.log('Select ShoutemApp target from xcode and activate "Automatically manage signing", ' +
        'select a provisioning profile and then rerun `shoutem run-ios`.');
      await exec(`open "${xcodeProjectPath}"`);
      const packagerProcess = (await packagerPromise).childProcess;
      await packagerProcess.kill('SIGINT');
    }
  } catch (exc) {
    try {
      const packagerProcess = (await packagerPromise).childProcess;
      await packagerProcess.kill('SIGINT');
    } catch (err) {
      // ignored
    }

    throw exc;
  }
}

if (output.indexOf('Code signing is required for product type') > 0) {
    let xcodeProjectPath;
    // if platform is used
    // last runtime configuration is required to get the mobile-app directory
    if (platformPath) {
      const runtimeConfig = await readJsonFile(await getPlatformConfigPath());
      const platform = _.find(runtimeConfig.included, {type: 'shoutem.core.platform-installations'});
      const version = _.get(platform, 'attributes.mobileAppVersion');
      xcodeProjectPath = path.join(await getPlatformsPath(), `v${version}`, 'ios', 'ShoutemApp.xcodeproj');
    } else {
      xcodeProjectPath = path.join(buildDirectory, 'ios', 'ShoutemApp.xcodeproj');
    }

    console.log('Select ShoutemApp target from xcode and activate "Automatically manage signing", ' +
      'select a provisioning profile and then rerun `shoutem run-ios`.');
    await exec(`open "${xcodeProjectPath}"`);
    return null;
  }

  if (output.indexOf('Unable to find a destination matching the provided destination specifier') > 0) {
    console.log('The app couldn\'t be run because of outdated Xcode version. Please update Xcode to 8.2.1 or later'.bold.red);
    return null;
  }

  console.log('Packager is being run within this process. Please keep this process running if app is used in debug mode'.bold.yellow);

  await packagerPromise;
}