Исходный код EJIO.utils.component.clock.time_class

## /utils/component/clock/time_class.py

from datetime import datetime

__all__ = [
    'Time',
]




class Time:
    """
    Класс представляет промежуток времени с точностью до наносекунд.
    Можно форматировать и получать в разных единицах.
    """
    __slots__ = ('_total_ns')

    def __init__(
            self,
            *,
            years: float = 0,
            days: float = 0,
            hours: float = 0,
            minutes: float = 0,
            seconds: float = 0,
            milliseconds: float = 0,
            microseconds: float = 0,
            nanoseconds: int = 0
    ) -> None:
        """
        Инициализация объекта Time из указанных единиц.

        :param years: Количество лет.
        :param days: Количество дней.
        :param hours: Количество часов.
        :param minutes: Количество минут.
        :param seconds: Количество секунд.
        :param milliseconds: Количество миллисекунд.
        :param microseconds: Количество микросекунд.
        :param nanoseconds: Количество наносекунд.
        """
        self._total_ns: int = int(
            years * 365 * 24 * 3600 * 1_000_000_000 +
            days * 24 * 3600 * 1_000_000_000 +
            hours * 3600 * 1_000_000_000 +
            minutes * 60 * 1_000_000_000 +
            seconds * 1_000_000_000 +
            milliseconds * 1_000_000 +
            microseconds * 1_000 +
            nanoseconds
        )



    @classmethod
    def from_datetime(cls, dt: datetime) -> 'Time':
        """
        Создает объект Time из объекта datetime.

        :param dt: Объект datetime.
        :return: Новый объект Time.
        """
        return cls(
            years=dt.year,
            days=dt.timetuple().tm_yday - 1,
            hours=dt.hour,
            minutes=dt.minute,
            seconds=dt.second,
            microseconds=dt.microsecond
        )


    def __add__(self, other: 'Time') -> 'Time':
        """
        Складывает два объекта Time и возвращает новый.

        :param other: Другой объект Time.
        :return: Новый объект Time, равный сумме.
        :raises: AttributeError, если other не Time
        """
        if not isinstance(other, Time):
            raise AttributeError('other must be of type Time')
        return Time(nanoseconds=self._total_ns + other._total_ns)

    def __sub__(self, other: 'Time') -> 'Time':
        """
        Вычитает один объект Time из другого.

        :param other: Объект Time для вычитания.
        :return: Новый объект Time, равный разности.
        :raises: AttributeError, если other не Time
        """
        if not isinstance(other, Time):
            raise AttributeError('other must be of type Time')
        return Time(nanoseconds=self._total_ns - other._total_ns)

    def __eq__(self, other: object) -> bool:
        """
        Проверяет равенство двух объектов Time.

        :param other: Другой объект.
        :return: True, если равны, иначе False.
        """
        return isinstance(other, Time) and self._total_ns == other._total_ns

    def __lt__(self, other: 'Time') -> bool:
        """
        Проверяет, меньше ли текущий объект, чем другой.

        :param other: Другой объект Time.
        :return: True, если текущий меньше, иначе False.
        :raises: AttributeError, если other не Time
        """
        if not isinstance(other, Time):
            raise AttributeError('other must be of type Time')
        return self._total_ns < other._total_ns

    def __le__(self, other: 'Time') -> bool:
        """
        Проверяет, меньше или равно ли текущее время другому.

        :param other: Другой объект Time.
        :return: True, если меньше или равно, иначе False.
        :raises: AttributeError, если other не Time
        """
        if not isinstance(other, Time):
            raise AttributeError('other must be of type Time')
        return self == other or self < other

    def __str__(self) -> str:
        """
        Строковое представление объекта.

        :return: Отформатированная строка времени.
        """
        return f'{self._total_ns / 1_000_000_000}'

    def __repr__(self) -> str:
        """
        Строковое представление объекта.

        :return: Отформатированная строка времени.
        """
        return self.format()



    def format(self, fmt: str = '%Y:%j:%H:%M:%S:%f') -> str:
        """
        Форматирует время согласно шаблону.

        %Y - Год
        %j - День
        %H - Часы
        %M - Минуты
        %S - Секунды
        %f - Микросекунды

        :param fmt: Формат строки, по умолчанию '%Y:%j:%H:%M:%S:%f'.
        :return: Отформатированная строка.
        """
        years = self.as_years()
        days = (self.as_days() % 365)
        hours = self.as_hours() % 24
        minutes = self.as_minutes() % 60
        seconds = self.as_seconds() % 60
        microseconds = self.as_microseconds() % 1_000_000

        out = fmt.replace('%Y', f'{int(years):04}')
        out = out.replace('%j', f'{int(days) + 1:03}')  # День от 1 до 366
        out = out.replace('%H', f'{int(hours):02}')
        out = out.replace('%M', f'{int(minutes):02}')
        out = out.replace('%S', f'{int(seconds):02}')
        out = out.replace('%f', f'{int(microseconds):06}')
        return out




    def as_nanoseconds(self) -> int:
        """
        Получить время в наносекундах.

        :return: Время в наносекундах.
        """
        return self._total_ns




    def as_microseconds(self) -> int:
        """
        Получить время в микросекундах.

        :return: Время в микросекундах.
        """
        return self._total_ns // 1_000




    def as_milliseconds(self) -> int:
        """
        Получить время в миллисекундах.

        :return: Время в миллисекундах.
        """
        return self._total_ns // 1_000_000




    def as_seconds(self) -> int:
        """
        Получить время в секундах.

        :return: Время в секундах.
        """
        return self._total_ns // 1_000_000_000




    def as_minutes(self) -> int:
        """
        Получить время в минутах.

        :return: Время в минутах.
        """
        return self.as_seconds() // 60




    def as_hours(self) -> int:
        """
        Получить время в часах.

        :return: Время в часах.
        """
        return self.as_minutes() // 60




    def as_days(self) -> int:
        """
        Получить время в днях.

        :return: Время в днях.
        """
        return self.as_hours() // 24




    def as_years(self) -> int:
        """
        Получить время в годах.

        :return: Время в годах.
        """
        return self.as_days() // 365