Call member services to get more tcerts
971113
private void getTCerts() {
        GetTCertBatchRequest req = new GetTCertBatchRequest(this.member.getName(), this.member.getEnrollment(),
                this.member.getTCertBatchSize(), attrs);
        try {
            List<TCert> tcerts = this.memberServices.getTCertBatch(req);
            // Add to member's tcert list
            for (TCert tcert : tcerts) {
                this.tcerts.push(tcert);
            }
        } catch (GetTCertBatchException e) {
            // ignore the exception for now
        }
    }
1270340
def get_tim(_, data):
    
    answers = {
        'DTIM Count': data[0],
        'DTIM Period': data[1],
        'Bitmap Control': data[2],
        'Bitmap[0]': data[3],
    }
    if len(data) - 4:
        answers['+ octets'] = len(data) - 4
    return answers
718559
def get_all(self, qry, tpl):
        '''  '''
        self.cur.execute(qry, tpl)
        result = self.cur.fetchall()
        return result
31364
def prt_tsv(self, prt, goea_results, **kws):
        """"""
        prt_flds = kws.get('prt_flds', self.get_prtflds_default(goea_results))
        tsv_data = MgrNtGOEAs(goea_results).get_goea_nts_prt(prt_flds, **kws)
        RPT.prt_tsv(prt, tsv_data, **kws)
528594
public static techsupport[] get(nitro_service client) throws Exception
	{
		techsupport resource = new techsupport();
		resource.validate("get");
		return (techsupport[]) resource.get_resources(client);
	}
526987
async function () {
    const oThis = this
    ;

    try {
      const stakerAddress = coreAddresses.getAddressForUser('staker')
        , stakerPassphrase = coreAddresses.getPassphraseForUser('staker');

      // Validations
      if (!basicHelper.isAddressValid(stakerAddress) || !stakerPassphrase) {
        let errObj = responseHelper.error({
          internal_error_identifier: 's_sam_ss_1',
          api_error_identifier: 'invalid_staker_details',
          error_config: basicHelper.fetchErrorConfig()
        });
        return Promise.resolve(errObj);
      }
      if (!basicHelper.isAddressValid(oThis.beneficiary)) {
        let errObj = responseHelper.error({
          internal_error_identifier: 's_sam_ss_2',
          api_error_identifier: 'invalid_beneficiary_details',
          error_config: basicHelper.fetchErrorConfig()
        });
        return Promise.resolve(errObj);
      }
      if (!basicHelper.isUuidValid(oThis.uuid)) {
        let errObj = responseHelper.error({
          internal_error_identifier: 's_sam_ss_3',
          api_error_identifier: 'invalid_branded_token_uuid',
          error_config: basicHelper.fetchErrorConfig()
        });
        return Promise.resolve(errObj);
      }
      if (!basicHelper.isNonZeroWeiValid(oThis.toStakeAmount)) {
        let errObj = responseHelper.error({
          internal_error_identifier: 's_sam_ss_4',
          api_error_identifier: 'invalid_amount',
          error_config: basicHelper.fetchErrorConfig()
        });
        return Promise.resolve(errObj);
      }

      // Format wei
      oThis.toStakeAmount = basicHelper.formatWeiToString(oThis.toStakeAmount);

      const stakeTransactionHash = await openSTValueContractInteract.stake(stakerAddress, stakerPassphrase, oThis.uuid,
        oThis.toStakeAmount, oThis.beneficiary, true);

      return Promise.resolve(responseHelper.successWithData({
        transaction_uuid: uuid.v4(),
        transaction_hash: stakeTransactionHash
      }));

    } catch (err) {
      let errObj = responseHelper.error({
        internal_error_identifier: 's_sam_ss_5',
        api_error_identifier: 'something_went_wrong',
        error_config: basicHelper.fetchErrorConfig()
      });
      return Promise.resolve(errObj);
    }
  }
741554
def update_tcs_table(self):
        
        g = get_root(self).globals
        if not g.cpars['tcs_on'] or not g.cpars['telins_name'].lower() == 'gtc':
            self.after(60000, self.update_tcs_table)
            return

        try:
            tel_server = tcs.get_telescope_server()
            telpars = tel_server.getTelescopeParams()
            add_gtc_header_table_row(self.tcs_table, telpars)
        except Exception as err:
            g.clog.warn('Could not update table of TCS info')

        # schedule next call for 60s later
        self.after(60000, self.update_tcs_table)
939763
function tiCalls( content, tmpl, data, options ) {
		if ( !content ) {
			return stack.pop();
		}
		stack.push({ _: content, tmpl: tmpl, item:this, data: data, options: options });
	}
986799
def getSplits(self, login, tableName, maxSplits):
    
    self.send_getSplits(login, tableName, maxSplits)
    return self.recv_getSplits()
10688
def _get_more(self):
        """"""
        if not self.alive:
            raise pymongo.errors.InvalidOperation(
                "Can't call get_more() on a MotorCursor that has been"
                " exhausted or killed.")

        self.started = True
        return self._refresh()
1223846
def dispatch(t):
    """"""

    if not t:
        return t
    else:
        t = list(t)

    # Make sure they're passing in something.
    assert len(t) >= 2

    # If only two items are passed in, assume HTTPBasic.
    if (len(t) == 2):
        t.insert(0, 'basic')

    # Allow built-in string referenced auths.
    if isinstance(t[0], basestring):
        if t[0] in ('basic', 'forced_basic'):
            t[0] = http_basic
        elif t[0] in ('digest',):
            t[0] = http_digest

    # Return a custom callable.
    return (t[0], tuple(t[1:]))
529274
async function getStudySetup() {
  // shallow copy
  const studySetup = Object.assign({}, baseStudySetup);

  studySetup.allowEnroll = await cachingFirstRunShouldAllowEnroll(studySetup);

  const testingOverrides = await browser.study.getTestingOverrides();
  studySetup.testing = {
    variationName: testingOverrides.variationName,
    firstRunTimestamp: testingOverrides.firstRunTimestamp,
    expired: testingOverrides.expired,
  };

  return studySetup;
}
782271
function updateCountSuccess(that) {
    if(that.expected !== undefined) {
        var countSuccess = that.count === that.expected
        that.countBlock.state.set("success", countSuccess)
        if(that.groupEnded) that.countBlock.results.state.set("late", true)

        if(countSuccess) {
            that.mainGroup.title.testTotalPasses++
            that.title.passed++
            if(that.groupEnded) {
                that.mainGroup.title.testTotalFailures--
                that.groupEndCountSubtracted = true // marks that failures were subtracted after the test finished (so successes can be later subtracted correctly if need be)
            }
        } else if(that.groupEndCountSubtracted || that.count - 1 === that.expected) {
            that.title.passed--
            that.mainGroup.title.testTotalPasses--
            if(that.groupEnded) {
                that.mainGroup.title.testTotalFailures++
            }
        }
    }
}
1281211
def get_tcntobj(self, go_all, **kws):
        """"""
        # kws: gaf (gene2go taxid)
        if 'gaf' in kws or 'gene2go' in kws:
            # Get a reduced go2obj set for TermCounts
            _gosubdag = GoSubDag(go_all, self.godag, rcntobj=False, prt=None)
            return get_tcntobj(_gosubdag.go2obj, **kws)
142678
def ntiles(self):
        
        tcum_mismatch = self.duration * 2 * pi * self.frequency / self.q
        return next_power_of_two(tcum_mismatch / self.deltam)
822908
function callNext(list, results, propogate) {
    var ret = new Promise().callback();
    forEach(list, function (listItem) {
        ret = ret.chain(propogate ? listItem : bindIgnore(null, listItem));
        if (!propogate) {
            ret.addCallback(function (res) {
                results.push(res);
                res = null;
            });
        }
    });
    return propogate ? ret.promise() : ret.chain(results);
}
61757
def refresh_committed_offsets_if_needed(self):
        """"""
        if self._subscription.needs_fetch_committed_offsets:
            offsets = self.fetch_committed_offsets(self._subscription.assigned_partitions())
            for partition, offset in six.iteritems(offsets):
                # verify assignment is still active
                if self._subscription.is_assigned(partition):
                    self._subscription.assignment[partition].committed = offset.offset
            self._subscription.needs_fetch_committed_offsets = False