Struct Schedule

pub struct Schedule {
    pub ueffective: NaiveDateTime,
    pub utermination: NaiveDateTime,
    pub frequency: Frequency,
    pub ufront_stub: Option<NaiveDateTime>,
    pub uback_stub: Option<NaiveDateTime>,
    pub calendar: Calendar,
    pub accrual_adjuster: Adjuster,
    pub payment_adjuster: Adjuster,
    pub uschedule: Vec<NaiveDateTime>,
    pub aschedule: Vec<NaiveDateTime>,
    pub pschedule: Vec<NaiveDateTime>,
}

A generic financial schedule with regular contiguous periods and, possibly, stubs.

Notes

• A regular schedule has a Frequency that perfectly divides its ueffective and utermination dates, and has no stub dates.
• An irregular schedule has a ufront_stub and/or uback_stub dates defining periods at the boundary of the schedule which are not a standard length of time defined by the Frequency. However, a regular schedule must exist between those interior dates.

Fields

ueffective: NaiveDateTime

The unadjusted start date of the schedule.

utermination: NaiveDateTime

The unadjusted end date of the schedule.

frequency: Frequency

The scheduling Frequency for regular periods.

ufront_stub: Option<NaiveDateTime>

The optional, unadjusted front stub date.

uback_stub: Option<NaiveDateTime>

The optional, unadjusted back stub date.

calendar: Calendar

The Calendar for accrual and payment date adjustment.

accrual_adjuster: Adjuster

The Adjuster to adjust the unadjusted schedule dates to adjusted period accrual dates.

payment_adjuster: Adjuster

The Adjuster to adjust the adjusted schedule dates to period payment dates.

uschedule: Vec<NaiveDateTime>

The vector of unadjusted period accrual dates.

aschedule: Vec<NaiveDateTime>

The vector of adjusted period accrual dates.

pschedule: Vec<NaiveDateTime>

The vector of payment dates associated with the adjusted accrual dates.

Implementations

impl Schedule

pub fn try_new_defined( ueffective: NaiveDateTime, utermination: NaiveDateTime, frequency: Frequency, ufront_stub: Option<NaiveDateTime>, uback_stub: Option<NaiveDateTime>, calendar: Calendar, accrual_adjuster: Adjuster, payment_adjuster: Adjuster, ) -> Result<Self, PyErr>

Create a Schedule from well defined unadjusted dates and a Frequency.

Notes

If provided arguments do not define a valid schedule pattern then an error is returned.

Examples

This is a valid schedule with a long back stub and regular monthly periods.

let s = Schedule::try_new_defined(
    ndt(2024, 1, 3), ndt(2024, 4, 15),                  // ueffective, utermination
    Frequency::Months{number:1, roll: Some(RollDay::Day(3))}, // frequency
    None, Some(ndt(2024, 3, 3)),                        // ufront_stub, uback_stub
    Cal::new(vec![], vec![5,6]).into(),                 // calendar
    Adjuster::ModifiedFollowing{},                      // accrual_adjuster
    Adjuster::BusDaysLagSettle(3),                      // payment_adjuster
);
assert_eq!(s.uschedule, vec![ndt(2024, 1, 3), ndt(2024, 2, 3), ndt(2024, 3, 3), ndt(2024, 4, 15)]);
assert_eq!(s.aschedule, vec![ndt(2024, 1, 3), ndt(2024, 2, 5), ndt(2024, 3, 4), ndt(2024, 4, 15)]);
assert_eq!(s.pschedule, vec![ndt(2024, 1, 8), ndt(2024, 2, 8), ndt(2024, 3, 7), ndt(2024, 4, 18)]);

This is not a valid schedule since there are no defined stubs and the dates do not align with the RollDay.

let s = Schedule::try_new_defined(
    ndt(2024, 1, 6), ndt(2024, 4, 6),                  // ueffective, utermination
    Frequency::Months{number:1, roll: Some(RollDay::Day(3))}, // frequency
    None, None,                                         // ufront_stub, uback_stub
    Cal::new(vec![], vec![5,6]).into(),                 // calendar
    Adjuster::ModifiedFollowing{},                      // accrual_adjuster
    Adjuster::BusDaysLagSettle(3),                      // payment_adjuster
);
assert!(s.is_err());

pub fn try_new_inferred( effective: NaiveDateTime, termination: NaiveDateTime, frequency: Frequency, front_stub: Option<NaiveDateTime>, back_stub: Option<NaiveDateTime>, calendar: Calendar, accrual_adjuster: Adjuster, payment_adjuster: Adjuster, eom: bool, stub_inference: Option<StubInference>, ) -> Result<Schedule, PyErr>

Create a Schedule using inference if some of the parameters are not well defined.

Notes

If all parameters are well defined and dates are definitively known in their unadjusted forms then the try_new_defined method should be used instead.

This method provides the additional features below:

• Unadjusted date inference: if adjusted dates are given then a neighbourhood of dates will be sub-sampled to determine any possibilities for unadjusted dates defined by the accrual_adjuster and calendar. Only the dates at either side of the regular schedule component are explored. Stub date boundaries are used as provided.
• Frequency inference: any Frequency that contains optional elements, e.g. no RollDay, will be explored for all possible alternatives that results in the most likely schedule, guided by the eom parameter.
• Stub date inference: one-sided stub date inference can be attempted guided by the stub_inference parameter.

pub fn is_regular(&self) -> bool

Check if a Schedule contains only regular periods, and no stub periods.

Trait Implementations

impl Clone for Schedule

fn clone(&self) -> Schedule

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Schedule

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Schedule

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'py> IntoPyObject<'py> for Schedule

type Target = Schedule

The Python output type

type Output = Bound<'py, <Schedule 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 Schedule

fn eq(&self, other: &Schedule) -> 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 Schedule

type Frozen = False

Whether the pyclass is frozen.

impl PyClassImpl for Schedule

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)]

const IS_IMMUTABLE_TYPE: bool = false

#[pyclass(immutable_type)]

type BaseType = PyAny

Base class

type ThreadChecker = SendablePyClass<Schedule>

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 PyClassNewTextSignature<Schedule> for PyClassImplCollector<Schedule>

fn new_text_signature(self) -> Option<&'static str>

impl<'a, 'py> PyFunctionArgument<'a, 'py, false> for &'a Schedule

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

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

impl<'a, 'py> PyFunctionArgument<'a, 'py, false> for &'a mut Schedule

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

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

impl PyMethods<Schedule> for PyClassImplCollector<Schedule>

fn py_methods(self) -> &'static PyClassItems

impl PyTypeInfo for Schedule

const NAME: &'static str = "Schedule"

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 is_type_of(object: &Bound<'_, PyAny>) -> bool

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

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

Checks if object is an instance of this type.

impl Serialize for Schedule

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl DerefToPyAny for Schedule

impl StructuralPartialEq for Schedule