Set the minimum lease period in months.
        :param min_lease: int
171335
def set_min_lease(self, min_lease):
        
        self._query_params += str(QueryParam.MIN_LEASE) + str(min_lease)
703342
private void setPeriodInternal(ReadablePeriod period) {
        int[] newValues = new int[size()];
        for (int i = 0, isize = period.size(); i < isize; i++) {
            DurationFieldType type = period.getFieldType(i);
            int value = period.getValue(i);
            checkAndUpdate(type, newValues, value);
        }
        setValues(newValues);
    }
1252080
def range_minmax(ranges):
    
    rmin = min(ranges)[0]
    rmax = max(ranges, key=lambda x: x[1])[1]
    return rmin, rmax
943041
public void setMin(Double min) {
        String minStr = doubleToNiceStr(min);
        JQMCommon.setAttribute(input, "min", minStr);
        refreshMin(input.getElement().getId(), minStr);
        validateValue();
    }
366088
public static void setMinTime(int mintime) {
    System.setProperty(MIN_TIME, String.valueOf(mintime));
    TimerTrace.mintime = mintime;
  }
843786
def set_min_price(self, min_price):
        

        if not isinstance(min_price, int):
            raise DaftException("Min price should be an integer.")

        self._min_price = str(min_price)
        self._price += str(QueryParam.MIN_PRICE) + self._min_price
991221
def lock_account(self, minutes=30):
        
        period = datetime.timedelta(minutes=minutes)
        self.locked_until = datetime.datetime.utcnow() + period
15960
@Override
    public void setPeriod(int pPeriod) {
	if (pPeriod < 0) {
	    throw new IllegalArgumentException("Period cannot be negative");
	}
	int actual = Math.max(pPeriod, MIN_PERIOD);
	log.debug("Changing clock period to {}", actual);
	period = actual;

	if (isRunning()) {
	    stop();
	    start(false);
	}
    }
674063
def set_quota(self, quota_bytes):
        
        self.set_library_metadata(ArcticLibraryBinding.QUOTA, quota_bytes)
        self.quota = quota_bytes
        self.quota_countdown = 0
405889
def lease(self, ttl=DEFAULT_TIMEOUT):
        
        result = self.post(self.get_url("/lease/grant"),
                           json={"TTL": ttl, "ID": 0})
        return Lease(int(result['ID']), client=self)
1252761
function(calendar) {
					while (m < calendar.minMonth) {
						y--;
						m += calendar.monthsInYear(y);
					}
					var yearMonths = calendar.monthsInYear(y);
					while (m > yearMonths - 1 + calendar.minMonth) {
						y++;
						m -= yearMonths;
						yearMonths = calendar.monthsInYear(y);
					}
				}
882916
public void setMinimumDuration(@NotNull final Duration minimumDuration) {
        if (minimumDuration.compareTo(MAXIMUM_DURATION) > 0) {
            throw new IllegalArgumentException("The minimum duaration has to be smaller than 23:59:59.");
        }
        this.minimumDuration = durationToDate(minimumDuration);
    }
1168906
def QA_util_add_months(dt, months):
    
    dt = datetime.datetime.strptime(
        dt, "%Y-%m-%d") + relativedelta(months=months)
    return(dt)
742789
def min_values(args):
    
    return Interval(min(x.low for x in args), min(x.high for x in args))
354703
def lease(self, seconds=600, num_tasks=1, tag=None):
    
    tag = tag if tag else None
    tasks = self._api.lease(
      numTasks=num_tasks, 
      seconds=seconds,
      groupByTag=(tag is not None),
      tag=tag,
    )

    if not len(tasks):
      raise QueueEmpty

    task = tasks[0]
    return totask(task)
704023
def _set_min_value(self, min_value):

        """"""

        # Check that the min value can be transformed if a transformation is present
        if self._transformation is not None:

            if min_value is not None:

                try:

                    _ = self._transformation.forward(min_value)

                except FloatingPointError:

                    raise ValueError("The provided minimum %s cannot be transformed with the transformation %s which "
                                     "is defined for the parameter %s" % (min_value,
                                                                          type(self._transformation),
                                                                          self.path))

        # Store the minimum as a pure float

        self._external_min_value = min_value

        # Check that the current value of the parameter is still within the boundaries. If not, issue a warning

        if self._external_min_value is not None and self.value < self._external_min_value:

            warnings.warn("The current value of the parameter %s (%s) "
                          "was below the new minimum %s." % (self.name, self.value, self._external_min_value),
                          exceptions.RuntimeWarning)

            self.value = self._external_min_value
574199
def attempt_renew_lease(self, lease_task, owned_by_others_q, lease_manager):
        
        loop = asyncio.new_event_loop()
        loop.run_until_complete(self.attempt_renew_lease_async(lease_task, owned_by_others_q, lease_manager))