""" Java time standard library APIs implemented in Python. java.time package - LocalDate, LocalTime, LocalDateTime, ZonedDateTime, Instant, Duration, Period, etc. """ from .._core import Stub from .lang import RuntimeException, Comparable import datetime as _dt import re as _re import math as _py_math IllegalArgumentException = type("IllegalArgumentException", (RuntimeException,), {}) __all__ = [ "LocalDate", "LocalTime", "LocalDateTime", "ZonedDateTime", "OffsetDateTime", "OffsetTime", "Instant", "Duration", "Period", "ZoneId", "ZoneOffset", "ZoneRules", "DayOfWeek", "Month", "Year", "YearMonth", "MonthDay", "Clock", "DateTimeFormatter", "DateTimeFormatterBuilder", "TemporalAdjusters", "Temporal", "TemporalAccessor", "TemporalUnit", "ChronoUnit", "ChronoField", ] # ============================================================ # TemporalAccessor / Temporal / TemporalUnit (base interfaces) # ============================================================ class TemporalAccessor(Stub): def get(self, field): raise NotImplementedError def getLong(self, field): raise NotImplementedError def isSupported(self, field): raise NotImplementedError def range(self, field): raise NotImplementedError class Temporal(TemporalAccessor): def plus(self, amount, unit=None): raise NotImplementedError def minus(self, amount, unit=None): raise NotImplementedError def with_(self, field, new_value): raise NotImplementedError def until(self, end_exclusive, unit): raise NotImplementedError class TemporalUnit(Stub): def getDuration(self): raise NotImplementedError def isDurationEstimated(self): raise NotImplementedError def isDateBased(self): raise NotImplementedError def isTimeBased(self): raise NotImplementedError def between(self, temporal1, temporal2): raise NotImplementedError # ============================================================ # ChronoField # ============================================================ class ChronoField(Stub): NANO_OF_SECOND = "NanoOfSecond" NANO_OF_DAY = "NanoOfDay" MICRO_OF_SECOND = "MicroOfSecond" MICRO_OF_DAY = "MicroOfDay" MILLI_OF_SECOND = "MilliOfSecond" MILLI_OF_DAY = "MilliOfDay" SECOND_OF_MINUTE = "SecondOfMinute" SECOND_OF_DAY = "SecondOfDay" MINUTE_OF_HOUR = "MinuteOfHour" MINUTE_OF_DAY = "MinuteOfDay" HOUR_OF_AMPM = "HourOfAmPm" CLOCK_HOUR_OF_AMPM = "ClockHourOfAmPm" HOUR_OF_DAY = "HourOfDay" CLOCK_HOUR_OF_DAY = "ClockHourOfDay" AMPM_OF_DAY = "AmPmOfDay" DAY_OF_WEEK = "DayOfWeek" ALIGNED_DAY_OF_WEEK_IN_MONTH = "AlignedDayOfWeekInMonth" ALIGNED_DAY_OF_WEEK_IN_YEAR = "AlignedDayOfWeekInYear" DAY_OF_MONTH = "DayOfMonth" DAY_OF_YEAR = "DayOfYear" EPOCH_DAY = "EpochDay" ALIGNED_WEEK_OF_MONTH = "AlignedWeekOfMonth" ALIGNED_WEEK_OF_YEAR = "AlignedWeekOfYear" MONTH_OF_YEAR = "MonthOfYear" PROLEPTIC_MONTH = "ProlepticMonth" YEAR_OF_ERA = "YearOfEra" YEAR = "Year" ERA = "Era" INSTANT_SECONDS = "InstantSeconds" OFFSET_SECONDS = "OffsetSeconds" def __init__(self, name): super().__init__() self._name = name def toString(self): return self._name def getDisplayName(self, locale=None): return self._name # ============================================================ # ChronoUnit # ============================================================ class ChronoUnit(Stub): NANOS = None MICROS = None MILLIS = None SECONDS = None MINUTES = None HOURS = None HALF_DAYS = None DAYS = None WEEKS = None MONTHS = None YEARS = None DECADES = None CENTURIES = None MILLENNIA = None ERAS = None FOREVER = None def __init__(self, name, duration, estimated=False): self._name = name self._duration = duration self._estimated = estimated def toString(self): return self._name def getDuration(self): return self._duration def isDurationEstimated(self): return self._estimated def isDateBased(self): return self in (ChronoUnit.WEEKS, ChronoUnit.MONTHS, ChronoUnit.YEARS, ChronoUnit.DECADES, ChronoUnit.CENTURIES, ChronoUnit.MILLENNIA, ChronoUnit.ERAS) def isTimeBased(self): return self in (ChronoUnit.NANOS, ChronoUnit.MICROS, ChronoUnit.MILLIS, ChronoUnit.SECONDS, ChronoUnit.MINUTES, ChronoUnit.HOURS, ChronoUnit.HALF_DAYS) def between(self, temporal1, temporal2): return temporal1.until(temporal2, self) @staticmethod def from_(temporal): if isinstance(temporal, ChronoUnit): return temporal raise Exception(f"Cannot convert to ChronoUnit: {temporal}") # ChronoUnit 常量在 Duration 定义之后初始化（见下方） # ============================================================ # DayOfWeek # ============================================================ class DayOfWeek(Stub): MONDAY = None TUESDAY = None WEDNESDAY = None THURSDAY = None FRIDAY = None SATURDAY = None SUNDAY = None def __init__(self, value, name): self._value = value self._name = name def getValue(self): return self._value def getDisplayName(self, style, locale=None): return self._name def plus(self, days): idx = ((self._value - 1 + days) % 7) + 1 return DayOfWeek._from_value(idx) def minus(self, days): return self.plus(-days) @staticmethod def _from_value(v): mapping = {1: DayOfWeek.MONDAY, 2: DayOfWeek.TUESDAY, 3: DayOfWeek.WEDNESDAY, 4: DayOfWeek.THURSDAY, 5: DayOfWeek.FRIDAY, 6: DayOfWeek.SATURDAY, 7: DayOfWeek.SUNDAY} return mapping.get(v) def toString(self): return self._name def compareTo(self, other): if isinstance(other, DayOfWeek): return self._value - other._value return -1 DayOfWeek.MONDAY = DayOfWeek(1, "MONDAY") DayOfWeek.TUESDAY = DayOfWeek(2, "TUESDAY") DayOfWeek.WEDNESDAY = DayOfWeek(3, "WEDNESDAY") DayOfWeek.THURSDAY = DayOfWeek(4, "THURSDAY") DayOfWeek.FRIDAY = DayOfWeek(5, "FRIDAY") DayOfWeek.SATURDAY = DayOfWeek(6, "SATURDAY") DayOfWeek.SUNDAY = DayOfWeek(7, "SUNDAY") # ============================================================ # Month # ============================================================ class Month(Stub): JANUARY = None FEBRUARY = None MARCH = None APRIL = None MAY = None JUNE = None JULY = None AUGUST = None SEPTEMBER = None OCTOBER = None NOVEMBER = None DECEMBER = None def __init__(self, value, name): self._value = value self._name = name def getValue(self): return self._value def getDisplayName(self, style, locale=None): return self._name def plus(self, months): idx = ((self._value - 1 + months) % 12) + 1 return Month._from_value(idx) def minus(self, months): return self.plus(-months) def length(self, leap_year=False): if self._value == 2: return 29 if leap_year else 28 if self._value in (4, 6, 9, 11): return 30 return 31 def minLength(self): return 29 if self._value == 2 else (30 if self._value in (4, 6, 9, 11) else 31) def maxLength(self): return 29 if self._value == 2 else (30 if self._value in (4, 6, 9, 11) else 31) def firstDayOfYear(self, leap_year=False): days = 0 for m in range(1, self._value): days += Month._from_value(m).length(leap_year) return days + 1 def firstMonthOfQuarter(self): q = (self._value - 1) // 3 return Month._from_value(q * 3 + 1) @staticmethod def _from_value(v): values = [None, Month.JANUARY, Month.FEBRUARY, Month.MARCH, Month.APRIL, Month.MAY, Month.JUNE, Month.JULY, Month.AUGUST, Month.SEPTEMBER, Month.OCTOBER, Month.NOVEMBER, Month.DECEMBER] return values[v] if 0 < v <= 12 else None def toString(self): return self._name def compareTo(self, other): if isinstance(other, Month): return self._value - other._value return -1 Month.JANUARY = Month(1, "JANUARY") Month.FEBRUARY = Month(2, "FEBRUARY") Month.MARCH = Month(3, "MARCH") Month.APRIL = Month(4, "APRIL") Month.MAY = Month(5, "MAY") Month.JUNE = Month(6, "JUNE") Month.JULY = Month(7, "JULY") Month.AUGUST = Month(8, "AUGUST") Month.SEPTEMBER = Month(9, "SEPTEMBER") Month.OCTOBER = Month(10, "OCTOBER") Month.NOVEMBER = Month(11, "NOVEMBER") Month.DECEMBER = Month(12, "DECEMBER") # ============================================================ # ZoneId / ZoneOffset / ZoneRules # ============================================================ class ZoneId(Stub): SHORT_IDS = { "ACT": "Australia/Darwin", "AET": "Australia/Sydney", "AGT": "America/Argentina/Buenos_Aires", "ART": "Africa/Cairo", "AST": "America/Anchorage", "BET": "America/Sao_Paulo", "BST": "Asia/Dhaka", "CAT": "Africa/Harare", "CNT": "America/St_Johns", "CST": "America/Chicago", "CTT": "Asia/Shanghai", "EAT": "Africa/Addis_Ababa", "ECT": "Europe/Paris", "EST": "America/New_York", "HST": "Pacific/Honolulu", "IET": "America/Indianapolis", "IST": "Asia/Kolkata", "JST": "Asia/Tokyo", "MIT": "Pacific/Apia", "MST": "America/Denver", "NET": "Asia/Yerevan", "NST": "Pacific/Auckland", "PLT": "Asia/Karachi", "PNT": "America/Phoenix", "PRT": "America/Puerto_Rico", "PST": "America/Los_Angeles", "SST": "Pacific/Guadalcanal", "VST": "Asia/Ho_Chi_Minh", } _cache = {} def __init__(self, zone_id): super().__init__() self._id = zone_id @staticmethod def systemDefault(): import time as _t idx = 1 if _t.daylight else 0 tz_name = _t.tzname[idx] if idx < len(_t.tzname) and _t.tzname[idx] else _t.tzname[0] return ZoneId.of(tz_name) if tz_name else ZoneId("UTC") @staticmethod def of(zone_id): if zone_id in ZoneId.SHORT_IDS: zone_id = ZoneId.SHORT_IDS[zone_id] if zone_id not in ZoneId._cache: ZoneId._cache[zone_id] = ZoneId(zone_id) return ZoneId._cache[zone_id] @staticmethod def getAvailableZoneIds(): import time as _t return set(_t.tzname) def getDisplayName(self, style, locale=None): return self._id def getRules(self): return ZoneRules() def toString(self): return self._id def equals(self, other): if isinstance(other, ZoneId): return self._id == other._id return False def hashCode(self): return hash(self._id) class ZoneOffset(ZoneId): MAX = None MIN = None UTC = None _cache = {} def __init__(self, total_seconds): hours = total_seconds // 3600 mins = (abs(total_seconds) % 3600) // 60 sign = "+" if total_seconds >= 0 else "-" if mins == 0: zone_id = f"{sign}{abs(hours):02d}:00" else: zone_id = f"{sign}{abs(hours):02d}:{mins:02d}" super().__init__(zone_id) self._total_seconds = total_seconds @staticmethod def of(offset_id): if offset_id in ZoneOffset._cache: return ZoneOffset._cache[offset_id] if offset_id == "Z" or offset_id == "UTC" or offset_id == "GMT": z = ZoneOffset(0) ZoneOffset._cache[offset_id] = z return z sign = 1 if offset_id[0] == "+" else -1 parts = offset_id[1:].split(":") h = int(parts[0]) m = int(parts[1]) if len(parts) > 1 else 0 total = sign * (h * 3600 + m * 60) z = ZoneOffset(total) ZoneOffset._cache[offset_id] = z return z @staticmethod def ofHours(hours): return ZoneOffset(hours * 3600) @staticmethod def ofHoursMinutes(hours, minutes): sign = 1 if hours >= 0 else -1 return ZoneOffset(sign * (abs(hours) * 3600 + minutes * 60)) @staticmethod def ofTotalSeconds(total_seconds): if total_seconds in ZoneOffset._cache: return ZoneOffset._cache[total_seconds] z = ZoneOffset(total_seconds) ZoneOffset._cache[total_seconds] = z return z def getTotalSeconds(self): return self._total_seconds def toString(self): if self._total_seconds == 0: return "Z" return super().toString() def equals(self, other): if isinstance(other, ZoneOffset): return self._total_seconds == other._total_seconds return False def hashCode(self): return self._total_seconds ZoneOffset.MAX = ZoneOffset(18 * 3600) ZoneOffset.MIN = ZoneOffset(-18 * 3600) ZoneOffset.UTC = ZoneOffset(0) class ZoneRules(Stub): def isFixedOffset(self): return True def getOffset(self, instant): return ZoneOffset.UTC def getDaylightSavings(self, instant): return Duration.ZERO def isDaylightSavings(self, instant): return False def isValidOffset(self, local_date_time, offset): return True def nextTransition(self, instant): return None def previousTransition(self, instant): return None def getTransitions(self): return [] def getTransitionRules(self): return [] # ============================================================ # Instant # ============================================================ class Instant(Temporal, Comparable): EPOCH = None def __init__(self, epoch_second, nano=0): super().__init__() self._epoch_second = int(epoch_second) self._nano = int(nano) @staticmethod def now(): import time as _t t = _t.time() sec = int(t) nano = int((t - sec) * 1_000_000_000) return Instant(sec, nano) @staticmethod def ofEpochMilli(epoch_milli): return Instant(epoch_milli // 1000, (epoch_milli % 1000) * 1_000_000) @staticmethod def ofEpochSecond(epoch_second, nano_adjustment=0): return Instant(epoch_second + nano_adjustment // 1_000_000_000, nano_adjustment % 1_000_000_000) def getEpochSecond(self): return self._epoch_second def getNano(self): return self._nano def toEpochMilli(self): return self._epoch_second * 1000 + self._nano // 1_000_000 def plus(self, seconds, nano=0): return Instant(self._epoch_second + seconds, self._nano + nano) def minus(self, seconds, nano=0): return self.plus(-seconds, -nano) def isBefore(self, other): if isinstance(other, Instant): return (self._epoch_second, self._nano) < (other._epoch_second, other._nano) return False def isAfter(self, other): if isinstance(other, Instant): return (self._epoch_second, self._nano) > (other._epoch_second, other._nano) return False def compareTo(self, other): if isinstance(other, Instant): diff = self._epoch_second - other._epoch_second if diff != 0: return -1 if diff < 0 else 1 diff = self._nano - other._nano return -1 if diff < 0 else (1 if diff > 0 else 0) return -1 def equals(self, other): if isinstance(other, Instant): return self._epoch_second == other._epoch_second and self._nano == other._nano return False def hashCode(self): return hash((self._epoch_second, self._nano)) def toString(self): return f"Instant({self._epoch_second},{self._nano})" Instant.EPOCH = Instant(0, 0) # ============================================================ # Duration # ============================================================ class Duration(Temporal, Comparable): ZERO = None def __init__(self, seconds, nanos=0): super().__init__() self._seconds = int(seconds) self._nanos = int(nanos) @staticmethod def ofDays(days): return Duration(days * 86400) @staticmethod def ofHours(hours): return Duration(hours * 3600) @staticmethod def ofMinutes(minutes): return Duration(minutes * 60) @staticmethod def ofSeconds(seconds): return Duration(seconds) @staticmethod def ofMillis(millis): return Duration(millis // 1000, (millis % 1000) * 1_000_000) @staticmethod def ofNanos(nanos): return Duration(nanos // 1_000_000_000, nanos % 1_000_000_000) @staticmethod def between(start, end): if isinstance(start, Instant) and isinstance(end, Instant): return Duration(end.getEpochSecond() - start.getEpochSecond(), end.getNano() - start.getNano()) return Duration.ZERO def getSeconds(self): return self._seconds def getNano(self): return self._nanos def toDays(self): return self._seconds // 86400 def toHours(self): return self._seconds // 3600 def toMinutes(self): return self._seconds // 60 def toSeconds(self): return self._seconds def toMillis(self): return self._seconds * 1000 + self._nanos // 1_000_000 def toNanos(self): return self._seconds * 1_000_000_000 + self._nanos def plus(self, duration): if isinstance(duration, Duration): return Duration(self._seconds + duration._seconds, self._nanos + duration._nanos) return self def minus(self, duration): if isinstance(duration, Duration): return Duration(self._seconds - duration._seconds, self._nanos - duration._nanos) return self def isNegative(self): return self._seconds < 0 or (self._seconds == 0 and self._nanos < 0) def isZero(self): return self._seconds == 0 and self._nanos == 0 def compareTo(self, other): if isinstance(other, Duration): diff = self._seconds - other._seconds if diff != 0: return -1 if diff < 0 else 1 diff = self._nanos - other._nanos return -1 if diff < 0 else (1 if diff > 0 else 0) return -1 def equals(self, other): if isinstance(other, Duration): return self._seconds == other._seconds and self._nanos == other._nanos return False def toString(self): return f"PT{self._seconds}S" def hashCode(self): return hash((self._seconds, self._nanos)) Duration.ZERO = Duration(0, 0) # === 延迟初始化 ChronoUnit 常量（必须在 Duration 定义之后） === ChronoUnit.NANOS = ChronoUnit("Nanos", Duration.ofNanos(1)) ChronoUnit.MICROS = ChronoUnit("Micros", Duration.ofNanos(1000)) ChronoUnit.MILLIS = ChronoUnit("Millis", Duration.ofNanos(1_000_000)) ChronoUnit.SECONDS = ChronoUnit("Seconds", Duration.ofSeconds(1)) ChronoUnit.MINUTES = ChronoUnit("Minutes", Duration.ofMinutes(1)) ChronoUnit.HOURS = ChronoUnit("Hours", Duration.ofHours(1)) ChronoUnit.HALF_DAYS = ChronoUnit("HalfDays", Duration.ofHours(12)) ChronoUnit.DAYS = ChronoUnit("Days", Duration.ofDays(1)) ChronoUnit.WEEKS = ChronoUnit("Weeks", Duration.ofDays(7)) ChronoUnit.MONTHS = ChronoUnit("Months", Duration.ofDays(30), estimated=True) ChronoUnit.YEARS = ChronoUnit("Years", Duration.ofDays(365), estimated=True) ChronoUnit.DECADES = ChronoUnit("Decades", Duration.ofDays(365 * 10), estimated=True) ChronoUnit.CENTURIES = ChronoUnit("Centuries", Duration.ofDays(365 * 100), estimated=True) ChronoUnit.MILLENNIA = ChronoUnit("Millennia", Duration.ofDays(365 * 1000), estimated=True) ChronoUnit.ERAS = ChronoUnit("Eras", Duration.ofDays(365 * 1_000_000_000), estimated=True) ChronoUnit.FOREVER = ChronoUnit("Forever", Duration.ofSeconds(1_000_000_000 * 86400 * 365), estimated=True) # ============================================================ # Period # ============================================================ class Period(Stub): ZERO = None def __init__(self, years, months, days): super().__init__() self._years = years self._months = months self._days = days @staticmethod def ofDays(days): return Period(0, 0, days) @staticmethod def ofWeeks(weeks): return Period(0, 0, weeks * 7) @staticmethod def ofMonths(months): return Period(0, months, 0) @staticmethod def ofYears(years): return Period(years, 0, 0) @staticmethod def between(start, end): if isinstance(start, LocalDate) and isinstance(end, LocalDate): return Period(end._year - start._year, end._month - start._month, end._day - start._day) return Period.ZERO def getYears(self): return self._years def getMonths(self): return self._months def getDays(self): return self._days def plus(self, period): if isinstance(period, Period): return Period(self._years + period._years, self._months + period._months, self._days + period._days) return self def minus(self, period): if isinstance(period, Period): return Period(self._years - period._years, self._months - period._months, self._days - period._days) return self def isZero(self): return self._years == 0 and self._months == 0 and self._days == 0 def isNegative(self): return self._years < 0 or self._months < 0 or self._days < 0 def equals(self, other): if isinstance(other, Period): return (self._years == other._years and self._months == other._months and self._days == other._days) return False def toString(self): return f"P{self._years}Y{self._months}M{self._days}D" def hashCode(self): return hash((self._years, self._months, self._days)) Period.ZERO = Period(0, 0, 0) # ============================================================ # LocalDate # ============================================================ class LocalDate(Temporal, Comparable): MIN = None MAX = None def __init__(self, year, month, day): super().__init__() self._year = year self._month = month self._day = day @staticmethod def now(zone=None): today = _dt.date.today() return LocalDate(today.year, today.month, today.day) @staticmethod def of(year, month, dayOfMonth): if isinstance(month, Month): month = month.getValue() return LocalDate(year, month, dayOfMonth) @staticmethod def parse(text, formatter=None): if formatter is None: parts = text.split("-") return LocalDate(int(parts[0]), int(parts[1]), int(parts[2])) return formatter.parse(text, LocalDate) def getYear(self): return self._year def getMonth(self): return Month._from_value(self._month) def getMonthValue(self): return self._month def getDayOfMonth(self): return self._day def getDayOfWeek(self): import time as _t import datetime as _dt2 d = _dt2.date(self._year, self._month, self._day) return DayOfWeek._from_value(d.isoweekday()) def getDayOfYear(self): d = _dt.date(self._year, self._month, self._day) return d.timetuple().tm_yday def getEra(self): return "CE" if self._year > 0 else "BCE" def isLeapYear(self): return _dt.date(self._year, 3, 1) - _dt.date(self._year, 2, 28) == _dt.timedelta(days=1) def lengthOfMonth(self): m = self._month if m == 2: return 29 if self.isLeapYear() else 28 if m in (4, 6, 9, 11): return 30 return 31 def lengthOfYear(self): return 366 if self.isLeapYear() else 365 def toEpochDay(self): d = _dt.date(self._year, self._month, self._day) return d.toordinal() def plusDays(self, days): d = _dt.date(self._year, self._month, self._day) + _dt.timedelta(days=days) return LocalDate(d.year, d.month, d.day) def plusWeeks(self, weeks): return self.plusDays(weeks * 7) def plusMonths(self, months): total = self._year * 12 + (self._month - 1) + months y = total // 12 m = (total % 12) + 1 d = min(self._day, 29 if m == 2 and _dt.date(y, 3, 1) - _dt.date(y, 2, 28) == _dt.timedelta(days=1) else 30 if m in (4, 6, 9, 11) else 31) return LocalDate(y, m, d) def plusYears(self, years): return self.plusMonths(years * 12) def minusDays(self, days): return self.plusDays(-days) def minusWeeks(self, weeks): return self.plusDays(-weeks * 7) def minusMonths(self, months): return self.plusMonths(-months) def minusYears(self, years): return self.plusYears(-years) def isBefore(self, other): if isinstance(other, LocalDate): return (self._year, self._month, self._day) < (other._year, other._month, other._day) return False def isAfter(self, other): if isinstance(other, LocalDate): return (self._year, self._month, self._day) > (other._year, other._month, other._day) return False def isEqual(self, other): if isinstance(other, LocalDate): return (self._year, self._month, self._day) == (other._year, other._month, other._day) return False def withDayOfMonth(self, day): return LocalDate(self._year, self._month, day) def withMonth(self, month): if isinstance(month, Month): month = month.getValue() return LocalDate(self._year, month, self._day) def withYear(self, year): return LocalDate(year, self._month, self._day) def atTime(self, hour, minute=0, second=0, nano=0): return LocalDateTime(self, LocalTime(hour, minute, second, nano)) def atStartOfDay(self, zone=None): return LocalDateTime(self, LocalTime.MIDNIGHT) def format(self, formatter): return formatter.format(self) def compareTo(self, other): if isinstance(other, LocalDate): v = self._year - other._year if v != 0: return -1 if v < 0 else 1 v = self._month - other._month if v != 0: return -1 if v < 0 else 1 v = self._day - other._day return -1 if v < 0 else (1 if v > 0 else 0) return -1 def equals(self, other): if isinstance(other, LocalDate): return (self._year, self._month, self._day) == (other._year, other._month, other._day) return False def toString(self): return f"{self._year:04d}-{self._month:02d}-{self._day:02d}" def hashCode(self): return hash((self._year, self._month, self._day)) LocalDate.MIN = LocalDate(-999999999, 1, 1) LocalDate.MAX = LocalDate(999999999, 12, 31) # ============================================================ # LocalTime # ============================================================ class LocalTime(Temporal, Comparable): MIDNIGHT = None NOON = None MIN = None MAX = None def __init__(self, hour, minute=0, second=0, nano=0): super().__init__() self._hour = hour self._minute = minute self._second = second self._nano = nano @staticmethod def now(zone=None): t = _dt.datetime.now().time() return LocalTime(t.hour, t.minute, t.second, t.microsecond * 1000) @staticmethod def of(hour, minute=0, second=0, nano=0): return LocalTime(hour, minute, second, nano) @staticmethod def parse(text, formatter=None): parts = text.split(":") h = int(parts[0]) m = int(parts[1]) s = int(parts[2]) if len(parts) > 2 else 0 return LocalTime(h, m, s) def getHour(self): return self._hour def getMinute(self): return self._minute def getSecond(self): return self._second def getNano(self): return self._nano def toSecondOfDay(self): return self._hour * 3600 + self._minute * 60 + self._second def toNanoOfDay(self): return self.toSecondOfDay() * 1_000_000_000 + self._nano def plusHours(self, h): total = self._hour + h return LocalTime(total % 24, self._minute, self._second, self._nano) def plusMinutes(self, m): total = self.toSecondOfDay() + m * 60 total %= 86400 h = total // 3600 total %= 3600 mi = total // 60 s = total % 60 return LocalTime(h, mi, s, self._nano) def plusSeconds(self, s): total = self.toSecondOfDay() + s total %= 86400 h = total // 3600 total %= 3600 mi = total // 60 sec = total % 60 return LocalTime(h, mi, sec, self._nano) def plusNanos(self, n): return LocalTime(self._hour, self._minute, self._second, self._nano + n) def minusHours(self, h): return self.plusHours(-h) def minusMinutes(self, m): return self.plusMinutes(-m) def minusSeconds(self, s): return self.plusSeconds(-s) def withHour(self, h): return LocalTime(h, self._minute, self._second, self._nano) def withMinute(self, m): return LocalTime(self._hour, m, self._second, self._nano) def withSecond(self, s): return LocalTime(self._hour, self._minute, s, self._nano) def withNano(self, n): return LocalTime(self._hour, self._minute, self._second, n) def atDate(self, date): return LocalDateTime(date, self) def isBefore(self, other): if isinstance(other, LocalTime): return self.toNanoOfDay() < other.toNanoOfDay() return False def isAfter(self, other): if isinstance(other, LocalTime): return self.toNanoOfDay() > other.toNanoOfDay() return False def format(self, formatter): return formatter.format(self) def compareTo(self, other): if isinstance(other, LocalTime): diff = self.toNanoOfDay() - other.toNanoOfDay() return -1 if diff < 0 else (1 if diff > 0 else 0) return -1 def equals(self, other): if isinstance(other, LocalTime): return (self._hour, self._minute, self._second, self._nano) == \ (other._hour, other._minute, other._second, other._nano) return False def toString(self): return f"{self._hour:02d}:{self._minute:02d}:{self._second:02d}" def hashCode(self): return hash((self._hour, self._minute, self._second, self._nano)) LocalTime.MIDNIGHT = LocalTime(0, 0, 0, 0) LocalTime.NOON = LocalTime(12, 0, 0, 0) LocalTime.MIN = LocalTime(0, 0, 0, 0) LocalTime.MAX = LocalTime(23, 59, 59, 999999999) # ============================================================ # LocalDateTime # ============================================================ class LocalDateTime(Temporal, Comparable): MIN = None MAX = None def __init__(self, date, time): super().__init__() self._date = date self._time = time @staticmethod def now(zone=None): now = _dt.datetime.now() date = LocalDate(now.year, now.month, now.day) time = LocalTime(now.hour, now.minute, now.second, now.microsecond * 1000) return LocalDateTime(date, time) @staticmethod def of(date_or_year, month=None, dayOfMonth=None, hour=None, minute=0, second=0, nano=0): if isinstance(date_or_year, LocalDate): return LocalDateTime(date_or_year, LocalTime(month or 0, dayOfMonth or 0, hour or 0)) return LocalDateTime(LocalDate(date_or_year, month, dayOfMonth), LocalTime(hour, minute, second, nano)) @staticmethod def parse(text, formatter=None): parts = text.split("T") date = LocalDate.parse(parts[0]) time = LocalTime.parse(parts[1]) if len(parts) > 1 else LocalTime.MIDNIGHT return LocalDateTime(date, time) def toLocalDate(self): return self._date def toLocalTime(self): return self._time def getYear(self): return self._date.getYear() def getMonth(self): return self._date.getMonth() def getMonthValue(self): return self._date.getMonthValue() def getDayOfMonth(self): return self._date.getDayOfMonth() def getDayOfWeek(self): return self._date.getDayOfWeek() def getDayOfYear(self): return self._date.getDayOfYear() def getHour(self): return self._time.getHour() def getMinute(self): return self._time.getMinute() def getSecond(self): return self._time.getSecond() def getNano(self): return self._time.getNano() def plusDays(self, d): return LocalDateTime(self._date.plusDays(d), self._time) def plusHours(self, h): return LocalDateTime(self._date, self._time.plusHours(h)) def plusMinutes(self, m): return LocalDateTime(self._date, self._time.plusMinutes(m)) def plusSeconds(self, s): return LocalDateTime(self._date, self._time.plusSeconds(s)) def minusDays(self, d): return self.plusDays(-d) def minusHours(self, h): return self.plusHours(-h) def minusMinutes(self, m): return self.plusMinutes(-m) def minusSeconds(self, s): return self.plusSeconds(-s) def withYear(self, y): return LocalDateTime(self._date.withYear(y), self._time) def withMonth(self, m): return LocalDateTime(self._date.withMonth(m), self._time) def withDayOfMonth(self, d): return LocalDateTime(self._date.withDayOfMonth(d), self._time) def atZone(self, zone): return ZonedDateTime(self, zone) def isBefore(self, other): if isinstance(other, LocalDateTime): if not self._date.isEqual(other._date): return self._date.isBefore(other._date) return self._time.isBefore(other._time) return False def isAfter(self, other): if isinstance(other, LocalDateTime): if not self._date.isEqual(other._date): return self._date.isAfter(other._date) return self._time.isAfter(other._time) return False def format(self, formatter): return formatter.format(self) def compareTo(self, other): if isinstance(other, LocalDateTime): c = self._date.compareTo(other._date) return c if c != 0 else self._time.compareTo(other._time) return -1 def equals(self, other): if isinstance(other, LocalDateTime): return self._date.equals(other._date) and self._time.equals(other._time) return False def toString(self): return f"{self._date}T{self._time}" def hashCode(self): return hash((self._date, self._time)) LocalDateTime.MIN = LocalDateTime(LocalDate.MIN, LocalTime.MIN) LocalDateTime.MAX = LocalDateTime(LocalDate.MAX, LocalTime.MAX) # ============================================================ # ZonedDateTime # ============================================================ class ZonedDateTime(Temporal, Comparable): def __init__(self, date_time, zone): super().__init__() self._date_time = date_time self._zone = zone @staticmethod def now(zone=None): ldt = LocalDateTime.now() z = zone or ZoneId.systemDefault() return ZonedDateTime(ldt, z) @staticmethod def of(date, time=None, zone=None, offset=None): if isinstance(date, LocalDateTime): return ZonedDateTime(date, time or ZoneId.systemDefault()) return ZonedDateTime(LocalDateTime.of(date, time), zone) @staticmethod def parse(text, formatter=None): return ZonedDateTime(LocalDateTime.now(), ZoneId.systemDefault()) def getZone(self): return self._zone def getOffset(self): return ZoneOffset.UTC def withZoneSameInstant(self, zone): return ZonedDateTime(self._date_time, zone) def withZoneSameLocal(self, zone): return ZonedDateTime(self._date_time, zone) def toLocalDate(self): return self._date_time.toLocalDate() def toLocalTime(self): return self._date_time.toLocalTime() def toLocalDateTime(self): return self._date_time def toInstant(self): return Instant.now() def plusDays(self, d): return ZonedDateTime(self._date_time.plusDays(d), self._zone) def plusHours(self, h): return ZonedDateTime(self._date_time.plusHours(h), self._zone) def minusDays(self, d): return self.plusDays(-d) def minusHours(self, h): return self.plusHours(-h) def format(self, formatter): return formatter.format(self) def compareTo(self, other): if isinstance(other, ZonedDateTime): return self._date_time.compareTo(other._date_time) return -1 def equals(self, other): if isinstance(other, ZonedDateTime): return self._date_time.equals(other._date_time) and str(self._zone) == str(other._zone) return False def toString(self): return f"{self._date_time}[{self._zone}]" def hashCode(self): return hash((self._date_time, str(self._zone))) # ============================================================ # OffsetDateTime / OffsetTime (stubs) # ============================================================ class OffsetDateTime(Temporal): def __init__(self, date_time, offset): super().__init__() self._date_time = date_time self._offset = offset @staticmethod def now(): return OffsetDateTime(LocalDateTime.now(), ZoneOffset.UTC) def toLocalDate(self): return self._date_time.toLocalDate() def toLocalTime(self): return self._date_time.toLocalTime() def toString(self): return f"{self._date_time}{self._offset}" class OffsetTime(Stub): def __init__(self, time, offset): super().__init__() self._time = time self._offset = offset @staticmethod def now(): return OffsetTime(LocalTime.now(), ZoneOffset.UTC) def toString(self): return f"{self._time}{self._offset}" # ============================================================ # Year / YearMonth / MonthDay # ============================================================ class Year(Temporal, Comparable): def __init__(self, year): super().__init__() self._year = year @staticmethod def now(): return Year(_dt.date.today().year) @staticmethod def of(year): return Year(year) def getValue(self): return self._year def isLeap(self): return _dt.date(self._year, 3, 1) - _dt.date(self._year, 2, 28) == _dt.timedelta(days=1) def length(self): return 366 if self.isLeap() else 365 def atMonth(self, month): if isinstance(month, Month): month = month.getValue() return YearMonth(self._year, month) def compareTo(self, other): if isinstance(other, Year): return -1 if self._year < other._year else (1 if self._year > other._year else 0) return -1 def toString(self): return str(self._year) class YearMonth(Temporal, Comparable): def __init__(self, year, month): super().__init__() self._year = year self._month = month @staticmethod def now(): d = _dt.date.today() return YearMonth(d.year, d.month) @staticmethod def of(year, month): return YearMonth(year, month) def getYear(self): return self._year def getMonth(self): return self._month def getMonthValue(self): return self._month if isinstance(self._month, int) else self._month.getValue() def lengthOfMonth(self): m = self.getMonthValue() if m == 2: return 29 if _dt.date(self._year, 3, 1) - _dt.date(self._year, 2, 28) == _dt.timedelta(days=1) else 28 return 30 if m in (4, 6, 9, 11) else 31 def lengthOfYear(self): return 366 if _dt.date(self._year, 3, 1) - _dt.date(self._year, 2, 28) == _dt.timedelta(days=1) else 365 def atDay(self, day): return LocalDate(self._year, self.getMonthValue(), day) def compareTo(self, other): if isinstance(other, YearMonth): diff = self._year - other._year if diff != 0: return -1 if diff < 0 else 1 diff = self.getMonthValue() - other.getMonthValue() return -1 if diff < 0 else (1 if diff > 0 else 0) return -1 def toString(self): return f"{self._year}-{self.getMonthValue():02d}" class MonthDay(Stub): def __init__(self, month, day): super().__init__() self._month = month self._day = day @staticmethod def now(): d = _dt.date.today() return MonthDay(d.month, d.day) @staticmethod def of(month, day): return MonthDay(month, day) def getMonth(self): return self._month def getMonthValue(self): return self._month if isinstance(self._month, int) else self._month.getValue() def getDayOfMonth(self): return self._day def atYear(self, year): return LocalDate.of(year, self.getMonthValue(), self._day) def toString(self): return f"--{self.getMonthValue():02d}-{self._day:02d}" # ============================================================ # Clock # ============================================================ class Clock(Stub): @staticmethod def systemUTC(): return Clock() @staticmethod def systemDefaultZone(): return Clock() @staticmethod def system(zone): return Clock() def millis(self): import time as _t return int(_t.time() * 1000) def instant(self): return Instant.now() def getZone(self): return ZoneId.systemDefault() # ============================================================ # DateTimeFormatter # ============================================================ class DateTimeFormatter(Stub): ISO_LOCAL_DATE = None ISO_LOCAL_TIME = None ISO_LOCAL_DATE_TIME = None ISO_INSTANT = None ISO_ZONED_DATE_TIME = None ISO_OFFSET_DATE_TIME = None def __init__(self, pattern): super().__init__() self._pattern = pattern @staticmethod def ofPattern(pattern): return DateTimeFormatter(pattern) def format(self, temporal): if isinstance(temporal, LocalDate): return temporal.toString() if isinstance(temporal, LocalTime): return temporal.toString() if isinstance(temporal, LocalDateTime): return temporal.toString() if isinstance(temporal, ZonedDateTime): return temporal.toString() if isinstance(temporal, Instant): return temporal.toString() return str(temporal) def parse(self, text, query=None): if query is LocalDate or query is None: return LocalDate.parse(text) if query is LocalTime: return LocalTime.parse(text) if query is LocalDateTime: return LocalDateTime.parse(text) return text DateTimeFormatter.ISO_LOCAL_DATE = DateTimeFormatter("yyyy-MM-dd") DateTimeFormatter.ISO_LOCAL_TIME = DateTimeFormatter("HH:mm:ss") DateTimeFormatter.ISO_LOCAL_DATE_TIME = DateTimeFormatter("yyyy-MM-ddTHH:mm:ss") DateTimeFormatter.ISO_INSTANT = DateTimeFormatter("yyyy-MM-ddTHH:mm:ssZ") DateTimeFormatter.ISO_ZONED_DATE_TIME = DateTimeFormatter("yyyy-MM-ddTHH:mm:ssZ") DateTimeFormatter.ISO_OFFSET_DATE_TIME = DateTimeFormatter("yyyy-MM-ddTHH:mm:ssZ") # ============================================================ # DateTimeFormatterBuilder (stub) # ============================================================ class DateTimeFormatterBuilder(Stub): def __init__(self): super().__init__() self._pattern_parts = [] def appendValue(self, field, width=1): return self def appendLiteral(self, literal): return self def appendPattern(self, pattern): self._pattern_parts.append(pattern) return self def toFormatter(self): return DateTimeFormatter("".join(self._pattern_parts)) # ============================================================ # TemporalAdjusters (stub) # ============================================================ class TemporalAdjusters(Stub): @staticmethod def firstDayOfMonth(): return lambda d: d.withDayOfMonth(1) @staticmethod def lastDayOfMonth(): return lambda d: d.withDayOfMonth(d.lengthOfMonth()) @staticmethod def firstDayOfYear(): return lambda d: d.withDayOfMonth(1).withMonth(1) @staticmethod def lastDayOfYear(): return lambda d: d.withDayOfMonth(31).withMonth(12) @staticmethod def firstInMonth(day_of_week): return lambda d: d @staticmethod def next(day_of_week): return lambda d: d.plusDays(1)