Struct Quota

pub struct Quota { /* private fields */ }

A rate-limiting quota.

Quotas are expressed in a positive number of “cells” (the maximum number of positive decisions / allowed items until the rate limiter needs to replenish) and the amount of time for the rate limiter to replenish a single cell.

Neither the number of cells nor the replenishment unit of time may be zero.

Burst sizes

There are multiple ways of expressing the same quota: a quota given as Quota::per_second(1) allows, on average, the same number of cells through as a quota given as Quota::per_minute(60). The quota of Quota::per_minute(60) has a burst size of 60 cells, meaning it is possible to accomodate 60 cells in one go, after which the equivalent of a minute of inactivity is required for the burst allowance to be fully restored.

Burst size gets really important when you construct a rate limiter that should allow multiple elements through at one time (using RateLimiter.check_n and its related functions): Only at most as many cells can be let through in one call as are given as the burst size.

In other words, the burst size is the maximum number of cells that the rate limiter will ever allow through without replenishing them.

Implementations

impl Quota

pub fn rate_per_second(max_burst: u32) -> PyResult<Self>

pub fn rate_per_minute(max_burst: u32) -> PyResult<Self>

pub fn rate_per_hour(max_burst: u32) -> PyResult<Self>

impl Quota

Constructors for Quotas

pub const fn per_second(max_burst: NonZeroU32) -> Self

Construct a quota for a number of cells per second. The given number of cells is also assumed to be the maximum burst size.

pub const fn per_minute(max_burst: NonZeroU32) -> Self

Construct a quota for a number of cells per 60-second period. The given number of cells is also assumed to be the maximum burst size.

pub const fn per_hour(max_burst: NonZeroU32) -> Self

Construct a quota for a number of cells per 60-minute (3600-second) period. The given number of cells is also assumed to be the maximum burst size.

pub const fn with_period(replenish_1_per: Duration) -> Option<Self>

Construct a quota that replenishes one cell in a given interval.

This constructor is meant to replace ::new, in cases where a longer refresh period than 1 cell/hour is necessary.

If the time interval is zero, returns None.

pub const fn allow_burst(self, max_burst: NonZeroU32) -> Self

Adjusts the maximum burst size for a quota to construct a rate limiter with a capacity for at most the given number of cells.

pub fn new(max_burst: NonZeroU32, replenish_all_per: Duration) -> Option<Self>

👎Deprecated since 0.2.0: This constructor is often confusing and non-intuitive. Use the per_(interval) / with_period and max_burst constructors instead.

Construct a quota for a given burst size, replenishing the entire burst size in that given unit of time.

Returns None if the duration is zero.

This constructor allows greater control over the resulting quota, but doesn’t make as much intuitive sense as other methods of constructing the same quotas. Unless your quotas are given as “max burst size, and time it takes to replenish that burst size”, you are better served by the Quota::per_second (and similar) constructors with the allow_burst modifier.

impl Quota

Retrieving information about a quota

pub const fn replenish_interval(&self) -> Duration

The time it takes for a rate limiter with an exhausted burst budget to replenish a single element.

pub const fn burst_size(&self) -> NonZeroU32

The maximum number of cells that can be allowed in one burst.

pub const fn burst_size_replenished_in(&self) -> Duration

The time it takes to replenish the entire maximum burst size.

Trait Implementations

impl Clone for Quota

fn clone(&self) -> Quota

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Quota

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl IntoPy<Py<PyAny>> for Quota

fn into_py(self, py: Python<'_>) -> PyObject

👎Deprecated since 0.23.0: IntoPy is going to be replaced by IntoPyObject. See the migration guide (https://pyo3.rs/v0.23.0/migration) for more information.

Performs the conversion.

impl<'py> IntoPyObject<'py> for Quota

type Target = Quota

The Python output type

type Output = Bound<'py, <Quota as IntoPyObject<'py>>::Target>

The smart pointer type to use.

type Error = PyErr

The type returned in the event of a conversion error.

fn into_pyobject( self, py: Python<'py>, ) -> Result<<Self as IntoPyObject<'_>>::Output, <Self as IntoPyObject<'_>>::Error>

Performs the conversion.

impl PartialEq for Quota

fn eq(&self, other: &Quota) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PyClass for Quota

type Frozen = False

Whether the pyclass is frozen.

impl PyClassImpl for Quota

const IS_BASETYPE: bool = false

#[pyclass(subclass)]

const IS_SUBCLASS: bool = false

#[pyclass(extends=…)]

const IS_MAPPING: bool = false

#[pyclass(mapping)]

const IS_SEQUENCE: bool = false

#[pyclass(sequence)]

type BaseType = PyAny

Base class

type ThreadChecker = SendablePyClass<Quota>

This handles following two situations:

type PyClassMutability = <<PyAny as PyClassBaseType>::PyClassMutability as PyClassMutability>::MutableChild

Immutable or mutable

type Dict = PyClassDummySlot

Specify this class has #[pyclass(dict)] or not.

type WeakRef = PyClassDummySlot

Specify this class has #[pyclass(weakref)] or not.

type BaseNativeType = PyAny

The closest native ancestor. This is PyAny by default, and when you declare #[pyclass(extends=PyDict)], it’s PyDict.

fn items_iter() -> PyClassItemsIter

fn doc(py: Python<'_>) -> PyResult<&'static CStr>

Rendered class doc

fn lazy_type_object() -> &'static LazyTypeObject<Self>

fn dict_offset() -> Option<isize>

fn weaklist_offset() -> Option<isize>

impl<'a, 'py> PyFunctionArgument<'a, 'py> for &'a Quota

type Holder = Option<PyRef<'py, Quota>>

fn extract( obj: &'a Bound<'py, PyAny>, holder: &'a mut Self::Holder, ) -> PyResult<Self>

impl<'a, 'py> PyFunctionArgument<'a, 'py> for &'a mut Quota

type Holder = Option<PyRefMut<'py, Quota>>

fn extract( obj: &'a Bound<'py, PyAny>, holder: &'a mut Self::Holder, ) -> PyResult<Self>

impl PyMethods<Quota> for PyClassImplCollector<Quota>

fn py_methods(self) -> &'static PyClassItems

impl PyTypeInfo for Quota

const NAME: &'static str = "Quota"

Class name.

const MODULE: Option<&'static str>

Module name, if any.

fn type_object_raw(py: Python<'_>) -> *mut PyTypeObject

Returns the PyTypeObject instance for this type.

fn type_object(py: Python<'_>) -> Bound<'_, PyType>

Returns the safe abstraction over the type object.

fn type_object_bound(py: Python<'_>) -> Bound<'_, PyType>

👎Deprecated since 0.23.0: renamed to PyTypeInfo::type_object

Deprecated name for [PyTypeInfo::type_object].

fn is_type_of(object: &Bound<'_, PyAny>) -> bool

Checks if object is an instance of this type or a subclass of this type.

fn is_type_of_bound(object: &Bound<'_, PyAny>) -> bool

👎Deprecated since 0.23.0: renamed to PyTypeInfo::is_type_of

Deprecated name for [PyTypeInfo::is_type_of].

fn is_exact_type_of(object: &Bound<'_, PyAny>) -> bool

Checks if object is an instance of this type.

fn is_exact_type_of_bound(object: &Bound<'_, PyAny>) -> bool

👎Deprecated since 0.23.0: renamed to PyTypeInfo::is_exact_type_of

Deprecated name for [PyTypeInfo::is_exact_type_of].

impl Copy for Quota

impl DerefToPyAny for Quota

impl Eq for Quota

impl StructuralPartialEq for Quota