#[cfg(windows)]

use crate::vm::convert::ToPyException;

use crate::vm::{

AsObject, Py, PyObject, PyObjectCell, PyObjectRef, PyPayload, PyRef, PyResult,

VirtualMachine,

builtins::{PyBytes, PyFloat, PyInt, PyStr, PyStrRef, PyTuple, PyType, PyTypeRef},

class::{PyClassImpl, StaticType},

common::{

hash::PyHash,

wtf8::{CodePoint, Wtf8Buf},

},

function::{ArgumentError, FromArgs, FuncArgs, OptionalArg, Param, PyComparisonValue},

protocol::{PyNumber, PyNumberMethods},

types::{AsNumber, Comparable, Constructor, Hashable, PyComparisonOp, Representable},

};

use crossbeam_utils::atomic::AtomicCell;

use malachite_bigint::{BigInt, ToBigInt};

use num_traits::{Signed, ToPrimitive, Zero};

#[pyattr]

const MINYEAR: i32 = 1;

#[pyattr]

const MAXYEAR: i32 = 9999;

/// `date(9999, 12, 31).toordinal()`

const MAXORDINAL: i32 = 3_652_059;

const MAX_DELTA_DAYS: i32 = 999_999_999;

const US_PER_MS: i64 = 1000;

const US_PER_SECOND: i64 = 1_000_000;

const US_PER_MINUTE: i64 = 60 * US_PER_SECOND;

const US_PER_HOUR: i64 = 60 * US_PER_MINUTE;

const SECONDS_PER_DAY: i64 = 24 * 3600;

const US_PER_DAY: i64 = SECONDS_PER_DAY * US_PER_SECOND;

const US_PER_WEEK: i64 = 7 * US_PER_DAY;

// Math and calendar helpers

/// Floor division and the matching non-negative remainder, for `y > 0`.

fn divmod(x: i64, y: i64) -> (i64, i64) {

debug_assert!(y > 0);

(x.div_euclid(y), x.rem_euclid(y))

}

/// Floor division and remainder with the sign of the divisor, as Python's `divmod`.

fn bigint_divmod(x: &BigInt, y: &BigInt) -> (BigInt, BigInt) {

let mut q = x / y;

let mut r = x % y;

if !r.is_zero() && (r.is_negative() != y.is_negative()) {

q -= 1;

r += y;

}

(q, r)

}

/// `_PyLong_DivmodNear`: `m / n` rounded to the nearest integer, ties to even.

fn divide_nearest(m: &BigInt, n: &BigInt, vm: &VirtualMachine) -> PyResult<BigInt> {

if n.is_zero() {

return Err(vm.new_zero_division_error("division by zero"));

}

let (q, r) = bigint_divmod(m, n);

// Round up when 2r > n, or 2r == n and q is odd (for n > 0; mirrored for n < 0).

let twice_r = &r * 2;

let greater = if n.is_negative() {

twice_r < *n

} else {

twice_r > *n

};

let tie = twice_r == *n;

let q_odd = (&q % 2u8) != BigInt::zero();

Ok(if greater || (tie && q_odd) { q + 1 } else { q })

}

const DAYS_IN_MONTH: [i32; 13] = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];

const DAYS_BEFORE_MONTH: [i32; 13] = [0, 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334];

fn is_leap(year: i32) -> bool {

let year = year as u32;

year.is_multiple_of(4) && (!year.is_multiple_of(100) || year.is_multiple_of(400))

}

fn days_in_month(year: i32, month: i32) -> i32 {

if month == 2 && is_leap(year) {

29

} else {

DAYS_IN_MONTH[month as usize]

}

}

fn days_before_month(year: i32, month: i32) -> i32 {

DAYS_BEFORE_MONTH[month as usize] + i32::from(month > 2 && is_leap(year))

}

fn days_before_year(year: i32) -> i32 {

let y = year - 1;

y * 365 + y / 4 - y / 100 + y / 400

}

const DI4Y: i32 = 1461;

const DI100Y: i32 = 36524;

const DI400Y: i32 = 146_097;

/// Ordinal (1 = 0001-01-01) to year, month, day.

fn ord_to_ymd(ordinal: i32) -> (i32, i32, i32) {

let ordinal = ordinal - 1;

let n400 = ordinal / DI400Y;

let n = ordinal % DI400Y;

let mut year = n400 * 400 + 1;

let n100 = n / DI100Y;

let n = n % DI100Y;

let n4 = n / DI4Y;

let n = n % DI4Y;

let n1 = n / 365;

let mut n = n % 365;

year += n100 * 100 + n4 * 4 + n1;

if n1 == 4 || n100 == 4 {

return (year - 1, 12, 31);

}

let leapyear = n1 == 3 && (n4 != 24 || n100 == 3);

let mut month = (n + 50) >> 5;

let mut preceding = DAYS_BEFORE_MONTH[month as usize] + i32::from(month > 2 && leapyear);

if preceding > n {

month -= 1;

preceding -= days_in_month(year, month);

}

n -= preceding;

(year, month, n + 1)

}

fn ymd_to_ord(year: i32, month: i32, day: i32) -> i32 {

days_before_year(year) + days_before_month(year, month) + day

}

/// Monday == 0 ... Sunday == 6.

fn weekday(year: i32, month: i32, day: i32) -> i32 {

(ymd_to_ord(year, month, day) + 6) % 7

}

/// Ordinal of the Monday starting ISO week 1 of `year`.

fn iso_week1_monday(year: i32) -> i32 {

let first_day = ymd_to_ord(year, 1, 1);

let first_weekday = (first_day + 6) % 7;

let week1_monday = first_day - first_weekday;

if first_weekday > 3 {

week1_monday + 7

} else {

week1_monday

}

}

/// ISO year, week, day to year, month, day; `Err` holds CPython's negative code.

fn iso_to_ymd(iso_year: i32, iso_week: i32, iso_day: i32) -> Result<(i32, i32, i32), i32> {

if !(MINYEAR..=MAXYEAR).contains(&iso_year) {

return Err(-4);

}

if iso_week <= 0 || iso_week >= 53 {

let mut out_of_range = true;

if iso_week == 53 {

let first_weekday = weekday(iso_year, 1, 1);

if first_weekday == 3 || (first_weekday == 2 && is_leap(iso_year)) {

out_of_range = false;

}

}

if out_of_range {

return Err(-2);

}

}

if iso_day <= 0 || iso_day >= 8 {

return Err(-3);

}

let day_1 = iso_week1_monday(iso_year);

let day_offset = (iso_week - 1) * 7 + iso_day - 1;

Ok(ord_to_ymd(day_1 + day_offset))

}

// Range checks

fn check_delta_day_range(days: i64, vm: &VirtualMachine) -> PyResult<i32> {

if (-i64::from(MAX_DELTA_DAYS)..=i64::from(MAX_DELTA_DAYS)).contains(&days) {

Ok(days as i32)

} else {

Err(vm.new_overflow_error(format!(

"days={days}; must have magnitude <= {MAX_DELTA_DAYS}"

)))

}

}

fn check_date_args(year: i32, month: i32, day: i32, vm: &VirtualMachine) -> PyResult<()> {

if !(MINYEAR..=MAXYEAR).contains(&year) {

return Err(

vm.new_value_error(format!("year must be in {MINYEAR}..{MAXYEAR}, not {year}"))

);

}

if !(1..=12).contains(&month) {

return Err(vm.new_value_error(format!("month must be in 1..12, not {month}")));

}

let dim = days_in_month(year, month);

if day < 1 || day > dim {

return Err(vm.new_value_error(format!(

"day {day} must be in range 1..{dim} for month {month} in year {year}"

)));

}

Ok(())

}

fn check_time_args(

h: i32,

m: i32,

s: i32,

us: i32,

fold: i32,

vm: &VirtualMachine,

) -> PyResult<()> {

if !(0..=23).contains(&h) {

return Err(vm.new_value_error(format!("hour must be in 0..23, not {h}")));

}

if !(0..=59).contains(&m) {

return Err(vm.new_value_error(format!("minute must be in 0..59, not {m}")));

}

if !(0..=59).contains(&s) {

return Err(vm.new_value_error(format!("second must be in 0..59, not {s}")));

}

if !(0..=999_999).contains(&us) {

return Err(vm.new_value_error(format!("microsecond must be in 0..999999, not {us}")));

}

if fold != 0 && fold != 1 {

return Err(vm.new_value_error(format!("fold must be either 0 or 1, not {fold}")));

}

Ok(())

}

// Normalization

/// Carry `lo` into `hi` until `0 <= lo < factor`.

fn normalize_pair(hi: &mut i64, lo: &mut i64, factor: i64) {

if *lo < 0 || *lo >= factor {

let (num_hi, rest) = divmod(*lo, factor);

*hi += num_hi;

*lo = rest;

}

}

fn normalize_d_s_us(d: &mut i64, s: &mut i64, us: &mut i64) {

normalize_pair(s, us, US_PER_SECOND);

normalize_pair(d, s, SECONDS_PER_DAY);

}

/// Bring an out-of-range day back into its month; `Err` when the year leaves the range.

fn normalize_y_m_d(y: &mut i64, m: &mut i64, d: &mut i64) -> Result<(), ()> {

let dim = i64::from(days_in_month(*y as i32, *m as i32));

if *d < 1 || *d > dim {

if *d == 0 {

*m -= 1;

if *m > 0 {

*d = i64::from(days_in_month(*y as i32, *m as i32));

} else {

*y -= 1;

*m = 12;

*d = 31;

}

} else if *d == dim + 1 {

*m += 1;

*d = 1;

if *m > 12 {

*m = 1;

*y += 1;

}

} else {

let ordinal = i64::from(ymd_to_ord(*y as i32, *m as i32, 1)) + *d - 1;

if ordinal < 1 || ordinal > i64::from(MAXORDINAL) {

return Err(());

}

let (ny, nm, nd) = ord_to_ymd(ordinal as i32);

(*y, *m, *d) = (i64::from(ny), i64::from(nm), i64::from(nd));

return Ok(());

}

}

if (i64::from(MINYEAR)..=i64::from(MAXYEAR)).contains(y) {

Ok(())

} else {

Err(())

}

}

fn date_overflow(vm: &VirtualMachine) -> crate::vm::builtins::PyBaseExceptionRef {

vm.new_overflow_error("date value out of range")

}

// Shared object helpers

/// `tp_name`: `datetime.timedelta` for the built-in types, the bare name for a subclass.

fn type_name(obj: &PyObject) -> String {

obj.class().slot_name().to_string()

}

fn checked_str_result(result: PyObjectRef, vm: &VirtualMachine) -> PyResult<PyStrRef> {

result.downcast::<PyStr>().map_err(|obj| {

vm.new_type_error(format!(

"__str__ returned non-string (type {})",

obj.class().slot_name()

))

})

}

/// Exact `int` value of an `int` (or subclass) object.

fn as_int(obj: &PyObject) -> Option<&BigInt> {

obj.downcast_ref::<PyInt>().map(|i| i.as_bigint())

}

/// `PyLong_FromDouble`, with CPython's errors for infinities and NaN.

fn float_to_bigint(value: f64, vm: &VirtualMachine) -> PyResult<BigInt> {

if value.is_nan() {

return Err(vm.new_value_error("cannot convert float NaN to integer"));

}

if value.is_infinite() {

return Err(vm.new_overflow_error("cannot convert float infinity to integer"));

}

Ok(value.to_bigint().expect("finite floats convert"))

}

/// `PyLong_AsInt` on an exact value.

fn bigint_to_i32(value: &BigInt, vm: &VirtualMachine) -> PyResult<i32> {

value

.to_i32()

.ok_or_else(|| vm.new_overflow_error("Python int too large to convert to C int"))

}

// timedelta

#[pyattr]

#[pyclass(module = "datetime", name = "timedelta")]

#[derive(Debug, PyPayload)]

pub(super) struct PyDelta {

#[pymember]

days: i32,

#[pymember]

seconds: i32,

#[pymember]

microseconds: i32,

hashcode: AtomicCell<PyHash>,

}

impl PyDelta {

fn new_unchecked(days: i32, seconds: i32, microseconds: i32) -> Self {

Self {

days,

seconds,

microseconds,

hashcode: AtomicCell::new(-1),

}

}

/// `new_delta_ex`: normalize when asked, check the day range and build an instance.

fn new_ex(

days: i64,

seconds: i64,

microseconds: i64,

normalize: bool,

vm: &VirtualMachine,

) -> PyResult<Self> {

let (mut d, mut s, mut us) = (days, seconds, microseconds);

if normalize {

normalize_d_s_us(&mut d, &mut s, &mut us);

}

let d = check_delta_day_range(d, vm)?;

Ok(Self::new_unchecked(d, s as i32, us as i32))

}

/// `new_delta`: a plain `timedelta` from components.

fn new_ref(

days: i64,

seconds: i64,

microseconds: i64,

normalize: bool,

vm: &VirtualMachine,

) -> PyResult<PyRef<Self>> {

Ok(Self::new_ex(days, seconds, microseconds, normalize, vm)?.into_ref(&vm.ctx))

}

fn to_microseconds(&self) -> i128 {

(i128::from(self.days) * i128::from(SECONDS_PER_DAY) + i128::from(self.seconds))

* i128::from(US_PER_SECOND)

+ i128::from(self.microseconds)

}

fn to_microseconds_big(&self) -> BigInt {

BigInt::from(self.to_microseconds())

}

/// `microseconds_to_delta_ex`

fn from_microseconds(us: &BigInt, vm: &VirtualMachine) -> PyResult<Self> {

let (seconds, us) = bigint_divmod(us, &BigInt::from(US_PER_SECOND));

let (days, seconds) = bigint_divmod(&seconds, &BigInt::from(SECONDS_PER_DAY));

let days = bigint_to_i32(&days, vm)?;

// `us` and `seconds` are in range by construction.

Self::new_ex(

i64::from(days),

seconds.to_i64().unwrap_or_default(),

us.to_i64().unwrap_or_default(),

false,

vm,

)

}

fn from_microseconds_ref(us: &BigInt, vm: &VirtualMachine) -> PyResult<PyRef<Self>> {

Ok(Self::from_microseconds(us, vm)?.into_ref(&vm.ctx))

}

fn from_microseconds_object(us: &PyObject, vm: &VirtualMachine) -> PyResult<Self> {

if us.class().is(vm.ctx.types.int_type) {

return Self::from_microseconds(as_int(us).unwrap(), vm);

}

let (seconds, us) = checked_delta_divmod(us, US_PER_SECOND, vm)?;

let us: i32 = us.try_into_value(vm)?;

if !(0..US_PER_SECOND as i32).contains(&us) {

return Err(vm.new_type_error("divmod() returned a value out of range"));

}

let (days, seconds) = checked_delta_divmod(&seconds, SECONDS_PER_DAY, vm)?;

let seconds: i32 = seconds.try_into_value(vm)?;

if !(0..SECONDS_PER_DAY as i32).contains(&seconds) {

return Err(vm.new_type_error("divmod() returned a value out of range"));

}

let days: i32 = days.try_into_value(vm)?;

Self::new_ex(

i64::from(days),

i64::from(seconds),

i64::from(us),

false,

vm,

)

}

fn is_nonzero(&self) -> bool {

self.days != 0 || self.seconds != 0 || self.microseconds != 0

}

fn cmp_key(&self) -> (i32, i32, i32) {

(self.days, self.seconds, self.microseconds)

}

fn negative(&self, vm: &VirtualMachine) -> PyResult<PyRef<Self>> {

Self::new_ref(

-i64::from(self.days),

-i64::from(self.seconds),

-i64::from(self.microseconds),

true,

vm,

)

}

fn getstate(&self, vm: &VirtualMachine) -> PyRef<PyTuple> {

vm.new_tuple((self.days, self.seconds, self.microseconds))

}

}

fn checked_delta_divmod(

value: &PyObject,

divisor: i64,

vm: &VirtualMachine,

) -> PyResult<(PyObjectRef, PyObjectRef)> {

let result = vm._divmod(value, vm.ctx.new_int(divisor).as_object())?;

let Some(tuple) = result.downcast_ref::<PyTuple>() else {

return Err(vm.new_type_error(format!(

"divmod() returned non-tuple (type {})",

type_name(&result)

)));

};

let [quotient, remainder] = tuple.as_slice() else {

return Err(vm.new_type_error(format!(

"divmod() returned a tuple of size {}",

tuple.as_slice().len()

)));

};

Ok((quotient.clone(), remainder.clone()))

}

enum DeltaSum {

Native(BigInt),

Object(PyObjectRef),

}

impl DeltaSum {

fn add_int(&mut self, term: BigInt, vm: &VirtualMachine) -> PyResult<()> {

match self {

Self::Native(value) => *value += term,

Self::Object(value) => {

*value = vm._add(value, vm.ctx.new_bigint(&term).as_object())?;

}

}

Ok(())

}

fn add_object(&mut self, term: &PyObject, vm: &VirtualMachine) -> PyResult<()> {

let result = match self {

Self::Native(value) => vm._add(vm.ctx.new_bigint(value).as_object(), term)?,

Self::Object(value) => vm._add(value, term)?,

};

*self = Self::Object(result);

Ok(())

}

fn is_odd(&self, vm: &VirtualMachine) -> PyResult<bool> {

match self {

Self::Native(value) => Ok((value % 2u8) != BigInt::zero()),

Self::Object(value) => vm

._and(value, vm.ctx.new_int(1).as_object())?

.try_to_bool(vm),

}

}

fn into_delta(self, vm: &VirtualMachine) -> PyResult<PyDelta> {

match self {

Self::Native(value) => PyDelta::from_microseconds(&value, vm),

Self::Object(value) => PyDelta::from_microseconds_object(&value, vm),

}

}

}

/// Fold `num` units of `factor` microseconds into `sofar`; float fractions go to `leftover`.

fn accum(

tag: &str,

sofar: &mut DeltaSum,

num: &PyObject,

factor: i64,

leftover: &mut f64,

vm: &VirtualMachine,

) -> PyResult<()> {

if let Some(int) = as_int(num) {

if num.class().is(vm.ctx.types.int_type) {

return sofar.add_int(int * factor, vm);

}

let product = vm._mul(num, vm.ctx.new_int(factor).as_object())?;

return sofar.add_object(&product, vm);

}

if let Some(float) = num.downcast_ref::<PyFloat>() {

let dnum = float.to_f64();

let intpart = dnum.trunc();

let fracpart = dnum - intpart;

sofar.add_int(float_to_bigint(intpart, vm)? * factor, vm)?;

if fracpart == 0.0 || !fracpart.is_finite() {

return Ok(());

}

let dnum = factor as f64 * fracpart;

let intpart = dnum.trunc();

sofar.add_int(float_to_bigint(intpart, vm)?, vm)?;

*leftover += dnum - intpart;

return Ok(());

}

Err(vm.new_type_error(format!(

"unsupported type for timedelta {tag} component: {}",

type_name(num)

)))

}

#[derive(FromArgs)]

pub(super) struct DeltaArgs {

#[pyarg(any, optional)]

days: OptionalArg<PyObjectRef>,

#[pyarg(any, optional)]

seconds: OptionalArg<PyObjectRef>,

#[pyarg(any, optional)]

microseconds: OptionalArg<PyObjectRef>,

#[pyarg(any, optional)]

milliseconds: OptionalArg<PyObjectRef>,

#[pyarg(any, optional)]

minutes: OptionalArg<PyObjectRef>,

#[pyarg(any, optional)]

hours: OptionalArg<PyObjectRef>,

#[pyarg(any, optional)]

weeks: OptionalArg<PyObjectRef>,

}

impl Constructor for PyDelta {

type Args = DeltaArgs;

fn py_new(_cls: &Py<PyType>, args: Self::Args, vm: &VirtualMachine) -> PyResult<Self> {

let mut x = DeltaSum::Native(BigInt::zero());

let mut leftover_us = 0.0f64;

let parts: [(&str, &OptionalArg<PyObjectRef>, i64); 7] = [

("microseconds", &args.microseconds, 1),

("milliseconds", &args.milliseconds, US_PER_MS),

("seconds", &args.seconds, US_PER_SECOND),

("minutes", &args.minutes, US_PER_MINUTE),

("hours", &args.hours, US_PER_HOUR),

("days", &args.days, US_PER_DAY),

("weeks", &args.weeks, US_PER_WEEK),

];

for (tag, value, factor) in parts {

if let OptionalArg::Present(value) = value {

accum(tag, &mut x, value, factor, &mut leftover_us, vm)?;

}

}

if leftover_us != 0.0 {

// Round to the nearest whole microsecond, ties to even.

let mut whole_us = leftover_us.round();

if (whole_us - leftover_us).abs() == 0.5 {

let x_is_odd = f64::from(u8::from(x.is_odd(vm)?));

whole_us = 2.0 * ((leftover_us + x_is_odd) * 0.5).round() - x_is_odd;

}

x.add_int(BigInt::from(whole_us as i64), vm)?;

}

x.into_delta(vm)

}

}

/// `delta_add` and friends take either operand as the `timedelta`.

fn as_delta(obj: &PyObject) -> Option<&Py<PyDelta>> {

obj.downcast_ref::<PyDelta>()

}

/// `float.as_integer_ratio()`, called as a method so subclasses can override it.

fn float_ratio(float: &PyObject, vm: &VirtualMachine) -> PyResult<(PyObjectRef, PyObjectRef)> {

let ratio = vm.call_method(float, "as_integer_ratio", ())?;

let Some(tuple) = ratio.downcast_ref::<PyTuple>() else {

return Err(vm.new_type_error(format!(

"unexpected return type from as_integer_ratio(): expected tuple, not '{}'",

type_name(&ratio)

)));

};

let [num, den] = tuple.as_slice() else {

return Err(vm.new_value_error("as_integer_ratio() must return a 2-tuple"));

};

Ok((num.clone(), den.clone()))

}

/// `multiply_truedivide_timedelta_float`: `divide` selects `/` over `*`.

fn delta_float_op(

delta: &PyDelta,

float: &PyObject,

divide: bool,

vm: &VirtualMachine,

) -> PyResult<PyRef<PyDelta>> {

let us = delta.to_microseconds_big();

let (num, den) = float_ratio(float, vm)?;

let (mul, div) = if divide { (den, num) } else { (num, den) };

let product = if mul.class().is(vm.ctx.types.int_type) {

us * as_int(&mul).unwrap()

} else {

let product = vm._mul(vm.ctx.new_bigint(&us).as_object(), &mul)?;

as_int(&product)

.cloned()

.ok_or_else(|| vm.new_type_error("divmod() requires ints"))?

};

let divisor = as_int(&div).ok_or_else(|| vm.new_type_error("divmod() requires ints"))?;

let out = divide_nearest(&product, divisor, vm)?;

PyDelta::from_microseconds_ref(&out, vm)

}

impl PyDelta {

fn nb_add(a: &PyObject, b: &PyObject, vm: &VirtualMachine) -> PyResult {

let (Some(a), Some(b)) = (as_delta(a), as_delta(b)) else {

return Ok(vm.ctx.not_implemented());

};

Ok(Self::new_ref(

i64::from(a.days) + i64::from(b.days),

i64::from(a.seconds) + i64::from(b.seconds),

i64::from(a.microseconds) + i64::from(b.microseconds),

true,

vm,

)?

.into())

}

fn nb_subtract(a: &PyObject, b: &PyObject, vm: &VirtualMachine) -> PyResult {

let (Some(a), Some(b)) = (as_delta(a), as_delta(b)) else {

return Ok(vm.ctx.not_implemented());

};

Ok(Self::new_ref(

i64::from(a.days) - i64::from(b.days),

i64::from(a.seconds) - i64::from(b.seconds),

i64::from(a.microseconds) - i64::from(b.microseconds),

true,

vm,

)?

.into())

}

fn nb_multiply(a: &PyObject, b: &PyObject, vm: &VirtualMachine) -> PyResult {

let (delta, other) = match (as_delta(a), as_delta(b)) {

(Some(delta), _) => (delta, b),

(None, Some(delta)) => (delta, a),

(None, None) => return Ok(vm.ctx.not_implemented()),

};

if let Some(int) = as_int(other) {

if other.class().is(vm.ctx.types.int_type) {

let us = delta.to_microseconds_big() * int;

return Ok(Self::from_microseconds_ref(&us, vm)?.into());

}

let us = vm._mul(

other,

vm.ctx.new_bigint(&delta.to_microseconds_big()).as_object(),

)?;

return Ok(Self::from_microseconds_object(&us, vm)?

.into_ref(&vm.ctx)

.into());

}

if other.downcast_ref::<PyFloat>().is_some() {

return Ok(delta_float_op(delta, other, false, vm)?.into());

}

Ok(vm.ctx.not_implemented())

}

fn nb_floor_divide(a: &PyObject, b: &PyObject, vm: &VirtualMachine) -> PyResult {

let Some(delta) = as_delta(a) else {

return Ok(vm.ctx.not_implemented());

};

if let Some(int) = as_int(b) {

if !b.class().is(vm.ctx.types.int_type) {

let us = vm._floordiv(

vm.ctx.new_bigint(&delta.to_microseconds_big()).as_object(),

b,

)?;

return Ok(Self::from_microseconds_object(&us, vm)?

.into_ref(&vm.ctx)

.into());

}

if int.is_zero() {