Can this RecurringCost be enacted
8411
def is_enactable(self, as_of):
        """"""
        return \
            not self.disabled and \
            not self.archived and \
            not self._is_finished(as_of) and \
            self._is_ready(as_of) and \
            not self._is_billing_complete()
275755
public void scheduleRecurring(Runnable runnable, Date firstTime, long period)
   {
	timer.scheduleAtFixedRate(toTimerTask(runnable), firstTime, period);
	
   }
193162
def lease(self):
        
        self._request_queue.put(
            requests.LeaseRequest(ack_id=self._ack_id, byte_size=self.size)
        )
1167225
def _recurring_setExpressCheckout_adapter(self, params):
        
        params['l_billingtype0'] = "RecurringPayments"
        params['l_billingagreementdescription0'] = params['desc']

        REMOVE = ["billingfrequency", "billingperiod", "profilestartdate", "desc"]
        for k in params.keys():
            if k in REMOVE:
                del params[k]

        return params
1251199
public void mutableSubtract(double c, Matrix B, ExecutorService threadPool)
    {
        mutableAdd(-c, B, threadPool);
    }
788507
private Periodic newPeriodic() {
        Periodic periodic = new Periodic();
        periodic.db = this.db;
        periodic.log = this.log;
        periodic.terminationGuard = this.terminationGuard;
        return periodic;
    }
841789
private static boolean canBeContinued(final byte[] data, final List<Policy> policies) {
		boolean result = true;
		for (Policy policy : policies) {
			result &= policy.continueCurrentFile(data);
		}
		return result;
	}
529259
protected boolean alreadyResettingRule(final RuleContext rc)
	{
		if (m_resettingRules.contains(rc))
		{
		    return true;
		}
		m_resettingRules.add(rc);
		return false;
	}
1221969
def recurring(self, offset=0, count=25):
        ''''''
        return self.client('jobs', 'recurring', self.name, offset, count)
1334339
public function setupRecurringPayments(string $currencyCode, string $paymentProviderId, float $replenishAmount, float $recurringAmount): BalanceInterface
    {
        $response = $this->client->post(
            $this->getBaseEndpointUri()->withPath("{$this->getBaseEndpointUri()->getPath()}/recurring-setup")->withQuery(http_build_query(['supportedCurrencyId' => $currencyCode])),
            (string) json_encode((object) [
                'providerId' => $paymentProviderId,
                'isRecurring' => 'true',
                'replenishAmount' => $replenishAmount,
                'recurringAmount' => $recurringAmount,
            ])
        );

        return $this->entitySerializer->deserialize(
            (string) $response->getBody(),
            $this->getEntityClass(),
            'json'
        );
    }
567382
def allowed_to_promote?(emendation)
      return unless emendation.amendment.rejected? && emendation.created_by?(current_user)
      return if promoted?(emendation)

      true
    end
899643
@Override
	@Transactional(enabled = false)
	public CPRuleAssetCategoryRel createCPRuleAssetCategoryRel(
		long CPRuleAssetCategoryRelId) {
		return cpRuleAssetCategoryRelPersistence.create(CPRuleAssetCategoryRelId);
	}
983271
def _may_override(self, implem, other):
        """"""
        if isinstance(other, ImplementationProperty):
            # Overriding another custom implementation for the same transition
            # and field
            return (other.transition == implem.transition and other.field_name == self.state_field)

        elif isinstance(other, TransitionWrapper):
            # Overriding the definition that led to adding the current
            # ImplementationProperty.
            return (
                other.trname == implem.transition.name
                and (not other.field or other.field == self.state_field)
                and other.func == implem.implementation)

        return False
69541
private boolean resubscribe() throws TransactionIdTooOldException,
      InterruptedException {
    for (NamespaceEventKey eventKey : watchedEvents.keySet()) {
      NamespaceEvent event = eventKey.getEvent(); 
      if (!subscribe(event.getPath(), EventType.fromByteValue(event.getType()),
          watchedEvents.get(eventKey))) {
        return false;
      }
    }
    return true;
  }
894940
function isActionsExistsInPermissionActions(allActions, schemaActions) {
    return utils.contains(allActions.sort().join(), schemaActions.sort().join());
}
569985
public boolean offer(long inUniqueId, TransactionInfoBaseMessage in)
    {
        ReplayEntry found = m_replayEntries.get(inUniqueId);

        if (in instanceof Iv2EndOfLogMessage) {
            m_mpiEOLReached = true;
            return true;
        }

        if (in instanceof MultiPartitionParticipantMessage) {
            //--------------------------------------------
            // DRv1 path, mark for future removal
            /*
             * DR sends multiple @LoadMultipartitionTable proc calls with the
             * same txnId, which is the snapshot txnId. For each partition,
             * there is a sentinel paired with the @LoadMultipartitionTable
             * call. Dedupe the sentinels the same way as we dedupe fragments,
             * so that there won't be sentinels end up in the sequencer where
             * matching fragments are deduped.
             */
            if (inUniqueId <= m_lastPolledFragmentUniqueId) {
                return true;
            }
            //--------------------------------------------
            if (found == null) {
                ReplayEntry newEntry = new ReplayEntry();
                newEntry.m_sentinelUniqueId = inUniqueId;
                m_replayEntries.put(inUniqueId, newEntry);
            }
            else {
                found.m_sentinelUniqueId = inUniqueId;
                assert(found.isReady());
            }
        }
        else if (in instanceof FragmentTaskMessage) {
            // already sequenced
            if (inUniqueId <= m_lastPolledFragmentUniqueId) {
                return false;
            }
            FragmentTaskMessage ftm  = (FragmentTaskMessage)in;
            if (found == null) {
                ReplayEntry newEntry = new ReplayEntry();
                newEntry.m_firstFragment = ftm;
                m_replayEntries.put(inUniqueId, newEntry);
            }
            else if (found.m_firstFragment == null) {
                found.m_firstFragment = ftm;
                assert(found.isReady());
            }
            else {
                found.addQueuedMessage(ftm);
            }
        }
        else if (in instanceof CompleteTransactionMessage) {
            // don't sequence CompleteTranscationMessage, throw them to scheduler directly
            return false;
        }
        else {
            //--------------------------------------------
            // DRv1 path, mark for future removal
            if (dedupe(inUniqueId, in) != null) {
                // Ignore an already seen txn
                return true;
            }
            //--------------------------------------------
            updateLastSeenUniqueId(inUniqueId, in);

            if (m_replayEntries.isEmpty() || !m_replayEntries.lastEntry().getValue().hasSentinel()) {
                // not-blocked work; rejected and not queued.
                return false;
            }
            else {
                // queued the message with the newest replayEntry
                m_replayEntries.lastEntry().getValue().addQueuedMessage(in);
            }
        }
        return true;
    }
156959
private function singleUseState()
    {
        if ($this->type === self::TYPE_SINGLE_USE) {
            if ($this->state === self::STATE_SINGLE_USE_USED) {
                throw new \BadMethodCallException('This single-use transaction has already been used.');
            }

            $this->state = self::STATE_SINGLE_USE_USED;

            return true;
        }

        return false;
    }