PARTIAL RELEASE Section 9.1.26
433821
def partialRelease():
    """"""
    a = TpPd(pd=0x6)
    b = MessageType(mesType=0xa)  # 00001010
    c = ChannelDescription()
    packet = a / b / c
    return packet
1079468
function cleanUpOldExecutable(next) {
        fs.unlink(nodeCompiler.releasePath, function(err) {
          if (err) {
            if (err.code === 'ENOENT') {
              next();
            } else {
              throw err;
            }
          } else {
            next();
          }
        });
      }
303251
def releaseCompleteMsToNet(Cause_presence=0, Facility_presence=0,
                           UserUser_presence=0, SsVersionIndicator_presence=0):
    """"""
    a = TpPd(pd=0x3)
    b = MessageType(mesType=0x2a)  # 00101010
    packet = a / b
    if Cause_presence is 1:
        c = CauseHdr(ieiC=0x08, eightBitC=0x0)
        packet = packet / c
    if Facility_presence is 1:
        d = FacilityHdr(ieiF=0x1C, eightBitF=0x0)
        packet = packet / d
    if UserUser_presence is 1:
        e = UserUserHdr(ieiUU=0x7E, eightBitUU=0x0)
        packet = packet / e
    if SsVersionIndicator_presence is 1:
        f = SsVersionIndicatorHdr(ieiSVI=0x7F, eightBitSVI=0x0)
        packet = packet / f
    return packet
326602
function include(partial, cb) {
    cb((params.partials && params.partials[partial]) ?
      params.partials[partial] :
      '[error] partial ' + partial + ' does not exist');
  }
1299318
def do_releases(self, subcmd, opts, component):
        

        releases = get_released_versions(component)
        for x in releases:
            print("{} - {}".format(*x))
1317851
def release():
    

    with settings(warn_only=True):
        r = local(clom.git['diff-files']('--quiet', '--ignore-submodules', '--'))

    if r.return_code != 0:
        abort('There are uncommitted changes, commit or stash them before releasing')

    version = open('VERSION.txt').read().strip()

    print('Releasing %s...' % version)
    local(clom.git.flow.release.start(version))
    local(clom.git.flow.release.finish(version, m='Release-%s' % version))
    local(clom.git.push('origin', 'master', 'develop', tags=True))
    local(clom.python('setup.py', 'sdist', 'upload'))
725298
function partial_processing(file) {
    const partial = {};

    partial.name = getNameFunc(directoryPath, file, extension);
    partial.path = path.join(...basePath, ...directoryPath, file);
    partial.source = fs.readFileSync(partial.path, encoding);

    partials.push(partial);
  }
17367
def _partial(self):
        """"""
        raw_stdout = self._process.readAllStandardOutput()
        stdout = handle_qbytearray(raw_stdout, self._get_encoding())

        if self._partial_stdout is None:
            self._partial_stdout = stdout
        else:
            self._partial_stdout += stdout

        self.sig_partial.emit(self, stdout, None)
889665
def release(self, login, package_name, version):
        '''
        
        '''
        url = '%s/release/%s/%s/%s' % (self.domain, login, package_name, version)
        res = self.session.get(url)
        self._check_response(res)
        return res.json()
1289277
function buildRelease() {
  var version = getVersion(), run = true;
  if (!version.match(/^\d.\d+\.\d+$/)) {
    warn('Release requires a valid x.x.x version!');
    run = false;
  }
  if (!run) process.exit();
  return mergeStreams([
    buildDevelopment(),
    buildMinified(),
    buildPackagesDefault()
  ]);
}
233089
def recognized_release(self):
        
        _, _, rest = self.get_release_parts()
        # If "rest" is not a well-known value here, then this package is
        # using a Release value pattern we cannot recognize.
        if rest == '' or re.match(r'%{\??dist}', rest):
            return True
        return False
1049955
private function savePartialData($partialDataSaved, $partialBase, $currBase, $partial, $curr, $quoteId)
    {
        if ($partialDataSaved) {
            /* get saved partial totals */
            $partialSavedBase = $partialDataSaved->getBasePartialAmount();
            $partialSaved = $partialDataSaved->getPartialAmount();
            if (
                ($partialSavedBase != $partialBase) ||
                ($partialSaved != $partial)
            ) {
                if ($partialBase > Cfg::DEF_ZERO) {
                    /* re-save quote partial in registry */
                    $partialDataSaved->setBasePartialAmount($partialBase);
                    $partialDataSaved->setPartialAmount($partial);
                    $this->daoPartialQuote->updateById($quoteId, $partialDataSaved);
                } else {
                    $this->daoPartialQuote->deleteById($quoteId);
                }
            }
        } else {
            if ($partialBase > Cfg::DEF_ZERO) {
                /* create new record in the registry */
                $partialDataSaved = new \Praxigento\Wallet\Repo\Data\Partial\Quote();
                $partialDataSaved->setQuoteRef($quoteId);
                $partialDataSaved->setBasePartialAmount($partialBase);
                $partialDataSaved->setBaseCurrency($currBase);
                $partialDataSaved->setPartialAmount($partial);
                $partialDataSaved->setCurrency($curr);
                $this->daoPartialQuote->create($partialDataSaved);
            }
        }
    }
1161881
function(ctx, partials, section) {
      var tail = ctx[ctx.length - 1],
          func,
          offset,
          arg;

      if (typeof tail == 'function') {
        func = tail;
        tail = ctx[ctx.length - 2];
        offset = this.buf.length;
      }

      if (!isArray(tail)) {
        section(ctx, partials, this);
      } else {
        for (var i = 0; i < tail.length; i++) {
          ctx.push(tail[i]);
          section(ctx, partials, this);
          ctx.pop();
        }
      }

      if (func) {
        arg = this.buf.substr(offset);
        this.buf = this.buf.substr(0, offset);
        this.b(func(arg));
      }
    }
613353
def validate_partial_uploads!(part_uids)
      input = Queue.new
      part_uids.each { |part_uid| input << part_uid }
      input.close

      results = Queue.new

      thread_count   = storage.concurrency[:concatenation] if storage.respond_to?(:concurrency)
      thread_count ||= 10

      threads = thread_count.times.map do
        Thread.new do
          begin
            loop do
              part_uid = input.pop or break
              part_info = storage.read_info(part_uid)
              results << Tus::Info.new(part_info)
            end
            nil
          rescue => error
            input.clear
            error
          end
        end
      end

      errors = threads.map(&:value).compact

      if errors.any? { |error| error.is_a?(Tus::NotFound) }
        error!(400, "One or more partial uploads were not found")
      elsif errors.any?
        fail errors.first
      end

      part_infos = Array.new(results.size) { results.pop } # convert Queue into an Array

      unless part_infos.all?(&:partial?)
        error!(400, "One or more uploads were not partial")
      end

      if max_size && part_infos.map(&:length).inject(0, :+) > max_size
        error!(400, "The sum of partial upload lengths exceed Tus-Max-Size")
      end
    end
1369770
def _release(level):
    """"""
    version, comment = _new_version(level)

    if version is not None:

        run(['git',
             'commit',
             str(VER_PATH.relative_to(BASE_PATH)),
             str(CHANGES_PATH.relative_to(BASE_PATH)),
             '--amend',
             '--no-edit',
             ])
        run(['git',
             'tag',
             '-a',
             'v' + version,
             '-m',
             '"' + comment + '"',
             ])
        run(['git',
             'push',
             'origin',
             '--tags',
             ])
        run(['git',
             'push',
             'origin',
             'master',
             '-f',
             ])
182020
async function buildUnreleasedPackages() {
	const cwdBefore = process.cwd();
	const unreleasedPackagesSourceFolder = path.resolve(__dirname, '../../packages/');
	const unreleasedPackagesDistFolder = path.resolve(__dirname, '../packages');
	await rimrafAsync(unreleasedPackagesDistFolder);
	await mkdirAsync(unreleasedPackagesDistFolder);
	process.chdir(unreleasedPackagesDistFolder);
	console.log('🎁  Packing current packages');
	await Promise.all(
		fs
			.readdirSync(unreleasedPackagesSourceFolder)
			.filter((packageName) => fs.statSync(path.join(unreleasedPackagesSourceFolder, packageName)).isDirectory())
			.map((packageName) => execAsync(`npm pack "${path.resolve(__dirname, '../../packages/' + packageName)}"`))
	);
	// Remove version number from file name
	await Promise.all(
		fs
			.readdirSync(unreleasedPackagesDistFolder)
			.filter((tarPackageName) => /\.tgz/.test(tarPackageName))
			.map((tarPackageName) =>
				renameAsync(
					path.join(unreleasedPackagesDistFolder, tarPackageName),
					path.join(unreleasedPackagesDistFolder, tarPackageName.replace(/\-\d[^-]+$/, '.tgz'))
				)
			)
	);

	process.chdir(cwdBefore);
}
61763
protected static function initStableRelease()
    {
        $releasePathStable = '';
        $path = \Deployer\get('deploy_path');
        $hasStableRelease = \Deployer\test("[ -d $path/current/ ]");
        if ($hasStableRelease) {

            // make shure we do not have an array at this point TODO: Check why this workaround is necessary
            $readlinkBin = \Deployer\get('readlink_bin');
            if (is_array($readlinkBin)) {
                $readlinkBin = current($readlinkBin);
            }

            if (PHP_OS === 'Darwin') {
                $releasePathStable = (string)\Deployer\run("$readlinkBin -n $path/current");
            } else {
                $releasePathStable = (string)\Deployer\run("$readlinkBin -f $path/current/");
            }
            \Deployer\set('release_path_stable', $releasePathStable);
        }
        if (\Deployer\isVerbose()) {
            \Deployer\writeln("release_path_stable = '{$releasePathStable}'");
        }
    }