duration.py

import dataclasses
import numpy as np

import armarx_core
from armarx_core.ice_conversion.ice_converter import IceConverter
from armarx_core import slice_loader
from armarx_memory.aron.aron_dataclass import AronDataclass

slice_loader.load_armarx_slice("ArmarXCore", "core/time.ice")
from armarx.core.time import dto

MIN_LONG_CPP = -9223372036854775808

@dataclasses.dataclass
class Duration(AronDataclass):
    microSeconds: np.int64 = MIN_LONG_CPP   # std::numeric_limits<long>::min()

    @staticmethod
    def from_seconds(seconds: float) -> "Duration":
        return Duration(np.int64(round(seconds * 1e6)))

    def as_seconds(self) -> float:
        print(self.microSeconds)
        return self.microSeconds * 1e-6

    def __repr__(self) -> str:
        return f"<Duration {self.microSeconds} µs>"

    def __str__(self) -> str:
        unit = "µs"
        time_count = self.microSeconds

        unit_ratios = [
            ("ms", 1000),
            ("s", 1000),
            ("min", 60),
            ("h", 60),
            ("d", 24),
        ]

        for unit_str, ratio in unit_ratios:
            if time_count >= ratio:
                time_count /= ratio
                unit = unit_str
            else:
                break

        return f"{time_count:.3f} {unit}"

class DurationIceConv(IceConverter):
    @classmethod
    def _import_dto(cls):
        return dto.Duration

    def _from_ice(self, dto: dto.Duration) -> Duration:
        return Duration(
            microSeconds=dto.microSeconds,
        )

    def _to_ice(self, bo: Duration) -> dto.Duration:
        return dto.Duration(
            microSeconds=bo.microSeconds,
        )


if __name__ == '__main__':
    conv = DurationIceConv()
    dt = dto.Duration(microSeconds=1200000)
    print(dt)
    bo = conv.from_ice(dt)
    print(bo)
    dt2 = conv.to_ice(bo)
    print(dt2)
    assert dt2 == dt

    # without converter, using standard aron conversions:
    dto = Duration.from_seconds(1.2)
    ice = dto.to_aron_ice()
    dto2 = Duration.from_aron_ice(ice)
    assert dto.as_seconds() == 1.2