crosshair-tool 0.0.56__cp39-cp39-macosx_11_0_arm64.whl → 0.0.100__cp39-cp39-macosx_11_0_arm64.whl

crosshair/libimpl/datetimelib.py

@@ -65,7 +65,7 @@ def _is_leap(year):
     return year % 4 == 0 and (year % 100 != 0 or year % 400 == 0)
 
 
-import z3
+import z3  # type: ignore
 
 
 def _smt_is_leap(smt_year):
@@ -440,7 +440,7 @@ def _check_utc_offset(name, offset):
     assert name in ("utcoffset", "dst")
     if offset is None:
         return
-    if not isinstance(offset, real_timedelta):
+    if not isinstance(offset, any_timedelta):
         raise TypeError(
             "tzinfo.%s() must return None "
             "or timedelta, not '%s'" % (name, type(offset))
@@ -486,7 +486,7 @@ def _check_time_fields(hour, minute, second, microsecond, fold):
 
 
 def _check_tzinfo_arg(tz):
-    if tz is not None and not isinstance(tz, real_tzinfo):
+    if tz is not None and not isinstance(tz, any_tzinfo):
         raise TypeError("tzinfo argument must be None or of a tzinfo subclass")
 
 
@@ -627,9 +627,7 @@ class timedelta:
 
     def total_seconds(self):
         """Total seconds in the duration."""
-        return (
-            (self.days * 86400 + self.seconds) * 10**6 + self.microseconds
-        ) / 10**6
+        return ((self.days * 86400 + self.seconds) * 10**6 + self.microseconds) / 10**6
 
     # Read-only field accessors
     @property
@@ -648,7 +646,7 @@ class timedelta:
         return self._microseconds
 
     def __add__(self, other):
-        if isinstance(other, real_timedelta):
+        if isinstance(other, any_timedelta):
             # for CPython compatibility, we cannot use
             # our __class__ here, but need a real timedelta
             return timedelta(
@@ -656,16 +654,16 @@ class timedelta:
                 self._seconds + other.seconds,
                 self._microseconds + other.microseconds,
             )
-        elif isinstance(other, real_datetime):
+        elif isinstance(other, any_datetime):
             return datetime.fromdatetime(other).__add__(self)
-        elif isinstance(other, real_date):
+        elif isinstance(other, any_date):
             return date.fromdate(other).__add__(self)
         return NotImplemented
 
     __radd__ = __add__
 
     def __sub__(self, other):
-        if isinstance(other, real_timedelta):
+        if isinstance(other, any_timedelta):
             # for CPython compatibility, we cannot use
             # our __class__ here, but need a real timedelta
             return timedelta(
@@ -673,14 +671,14 @@ class timedelta:
                 self._seconds - other.seconds,
                 self._microseconds - other.microseconds,
             )
-        elif isinstance(other, real_date):
+        elif isinstance(other, any_date):
             return date.fromdate(other).__add__(self)
-        elif isinstance(other, real_datetime):
+        elif isinstance(other, any_datetime):
             return datetime.fromdatetime(other).__add__(self)
         return NotImplemented
 
     def __rsub__(self, other):
-        if isinstance(other, real_timedelta):
+        if isinstance(other, any_timedelta):
             return -self + other
         return NotImplemented
 
@@ -714,19 +712,19 @@ class timedelta:
     __rmul__ = __mul__
 
     def __floordiv__(self, other):
-        if not isinstance(other, (int, real_timedelta)):
+        if not isinstance(other, (int, any_timedelta)):
             return NotImplemented
         usec = _timedelta_to_microseconds(self)
-        if isinstance(other, real_timedelta):
+        if isinstance(other, any_timedelta):
             return usec // _timedelta_to_microseconds(other)
         if isinstance(other, int):
             return timedelta(0, 0, usec // other)
 
     def __truediv__(self, other):
-        if not isinstance(other, (int, float, real_timedelta)):
+        if not isinstance(other, (int, float, any_timedelta)):
             return NotImplemented
         usec = _timedelta_to_microseconds(self)
-        if isinstance(other, real_timedelta):
+        if isinstance(other, any_timedelta):
             return usec / _timedelta_to_microseconds(other)
         if isinstance(other, int):
             return timedelta(0, 0, _divide_and_round(usec, other))
@@ -735,13 +733,13 @@ class timedelta:
             return timedelta(0, 0, _divide_and_round(b * usec, a))
 
     def __mod__(self, other):
-        if isinstance(other, real_timedelta):
+        if isinstance(other, any_timedelta):
             r = _timedelta_to_microseconds(self) % _timedelta_to_microseconds(other)
             return timedelta(0, 0, r)
         return NotImplemented
 
     def __divmod__(self, other):
-        if isinstance(other, real_timedelta):
+        if isinstance(other, any_timedelta):
             q, r = divmod(
                 _timedelta_to_microseconds(self), _timedelta_to_microseconds(other)
             )
@@ -751,37 +749,37 @@ class timedelta:
     # Comparisons of timedelta objects with other.
 
     def __eq__(self, other):
-        if isinstance(other, real_timedelta):
+        if isinstance(other, any_timedelta):
             return self._cmp(other) == 0
         else:
             return NotImplemented
 
     def __le__(self, other):
-        if isinstance(other, real_timedelta):
+        if isinstance(other, any_timedelta):
             return self._cmp(other) <= 0
         else:
             return NotImplemented
 
     def __lt__(self, other):
-        if isinstance(other, real_timedelta):
+        if isinstance(other, any_timedelta):
             return self._cmp(other) < 0
         else:
             return NotImplemented
 
     def __ge__(self, other):
-        if isinstance(other, real_timedelta):
+        if isinstance(other, any_timedelta):
             return self._cmp(other) >= 0
         else:
             return NotImplemented
 
     def __gt__(self, other):
-        if isinstance(other, real_timedelta):
+        if isinstance(other, any_timedelta):
             return self._cmp(other) > 0
         else:
             return NotImplemented
 
     def _cmp(self, other):
-        assert isinstance(other, real_timedelta)
+        assert isinstance(other, any_timedelta)
         return _cmp(_timedelta_getstate(self), _timedelta_getstate(other))
 
     def __hash__(self):
@@ -811,6 +809,8 @@ class timedelta:
         return real_timedelta
 
 
+any_timedelta = (timedelta, real_timedelta)
+
 timedelta.min = timedelta(-999999999)  # type: ignore
 timedelta.max = timedelta(  # type: ignore
     days=999999999, hours=23, minutes=59, seconds=59, microseconds=999999
@@ -855,7 +855,7 @@ class date:
 
     """
 
-    def __init__(self, year, month, day):
+    def __init__(self, year, month=None, day=None):
         """
         Constructor.
 
@@ -863,7 +863,13 @@ class date:
         :param month: month, starting at 1
         :param day: day, starting at 1
         """
-        year, month, day = _check_date_fields(year, month, day)
+        if month is None:
+            # We can receive a string/bytes single argument when unpickling a concrete date
+            with NoTracing():
+                dt = real_date(realize(year))  # type: ignore
+                year, month, day = dt.year, dt.month, dt.day
+        else:
+            year, month, day = _check_date_fields(year, month, day)
         self._year = year
         self._month = month
         self._day = day
@@ -1044,32 +1050,32 @@ class date:
     # Comparisons of date objects with other.
 
     def __eq__(self, other):
-        if isinstance(other, real_date):
+        if isinstance(other, any_date):
             return self._cmp(other) == 0
         return NotImplemented
 
     def __le__(self, other):
-        if isinstance(other, real_date):
+        if isinstance(other, any_date):
             return self._cmp(other) <= 0
         return NotImplemented
 
     def __lt__(self, other):
-        if isinstance(other, real_date):
+        if isinstance(other, any_date):
             return self._cmp(other) < 0
         return NotImplemented
 
     def __ge__(self, other):
-        if isinstance(other, real_date):
+        if isinstance(other, any_date):
             return self._cmp(other) >= 0
         return NotImplemented
 
     def __gt__(self, other):
-        if isinstance(other, real_date):
+        if isinstance(other, any_date):
             return self._cmp(other) > 0
         return NotImplemented
 
     def _cmp(self, other):
-        assert isinstance(other, real_date)
+        assert isinstance(other, any_date)
         y, m, d = self._year, self._month, self._day
         y2, m2, d2 = other.year, other.month, other.day
         return _cmp((y, m, d), (y2, m2, d2))
@@ -1083,7 +1089,7 @@ class date:
 
     def __add__(self, other):
         """Add a date to a timedelta."""
-        if isinstance(other, real_timedelta):
+        if isinstance(other, any_timedelta):
             o = self.toordinal() + other.days
             if 0 < o <= _MAXORDINAL:
                 return date.fromordinal(o)
@@ -1094,9 +1100,9 @@ class date:
 
     def __sub__(self, other):
         """Subtract two dates, or a date and a timedelta."""
-        if isinstance(other, real_timedelta):
+        if isinstance(other, any_timedelta):
             return self + timedelta(-other.days)
-        if isinstance(other, real_date):
+        if isinstance(other, any_date):
             days1 = self.toordinal()
             days2 = other.toordinal()
             return timedelta(days1 - days2)
@@ -1149,6 +1155,8 @@ class date:
         return real_date
 
 
+any_date = (date, real_date)
+
 _date_class = date  # so functions w/ args named "date" can get at the class
 
 date.min = date(1, 1, 1)  # type: ignore
@@ -1182,7 +1190,7 @@ class tzinfo:
 
     def fromutc(self, dt):
         """datetime in UTC -> datetime in local time."""
-        if not isinstance(dt, real_datetime):
+        if not isinstance(dt, any_datetime):
             raise TypeError("fromutc() requires a datetime argument")
         if dt.tzinfo is not self:
             raise ValueError("dt.tzinfo is not self")
@@ -1226,6 +1234,9 @@ class tzinfo:
         return real_tzinfo
 
 
+any_tzinfo = (tzinfo, real_tzinfo)
+
+
 class IsoCalendarDate(tuple):
     def __new__(cls, year, week, weekday):
         return super().__new__(cls, (year, week, weekday))
@@ -1339,37 +1350,37 @@ class time:
     # Comparisons of time objects with other.
 
     def __eq__(self, other):
-        if isinstance(other, real_time):
+        if isinstance(other, any_time):
             return self._cmp(other, allow_mixed=True) == 0
         else:
             return NotImplemented
 
     def __le__(self, other):
-        if isinstance(other, real_time):
+        if isinstance(other, any_time):
             return self._cmp(other) <= 0
         else:
             return NotImplemented
 
     def __lt__(self, other):
-        if isinstance(other, real_time):
+        if isinstance(other, any_time):
             return self._cmp(other) < 0
         else:
             return NotImplemented
 
     def __ge__(self, other):
-        if isinstance(other, real_time):
+        if isinstance(other, any_time):
             return self._cmp(other) >= 0
         else:
             return NotImplemented
 
     def __gt__(self, other):
-        if isinstance(other, real_time):
+        if isinstance(other, any_time):
             return self._cmp(other) > 0
         else:
             return NotImplemented
 
     def _cmp(self, other, allow_mixed=False):
-        assert isinstance(other, real_time)
+        assert isinstance(other, any_time)
         mytz = self._tzinfo
         ottz = other.tzinfo
         myoff = otoff = None
@@ -1582,6 +1593,8 @@ class time:
         return real_time
 
 
+any_time = (time, real_time)
+
 _time_class = time  # so functions w/ args named "time" can get at the class
 
 time.min = time(0, 0, 0)  # type: ignore
@@ -1741,9 +1754,9 @@ class datetime(date):
     @classmethod
     def combine(cls, date, time, tzinfo=True):
         """Construct a datetime from a given date and a given time."""
-        if not isinstance(date, real_date):
+        if not isinstance(date, any_date):
             raise TypeError("date argument must be a date instance")
-        if not isinstance(time, real_time):
+        if not isinstance(time, any_time):
             raise TypeError("time argument must be a time instance")
         if tzinfo is True:
             tzinfo = time.tzinfo
@@ -1935,7 +1948,7 @@ class datetime(date):
     def astimezone(self, tz=None):
         if tz is None:
             tz = self._local_timezone()
-        elif not isinstance(tz, real_tzinfo):
+        elif not isinstance(tz, any_tzinfo):
             raise TypeError("tz argument must be an instance of tzinfo")
 
         mytz = self.tzinfo
@@ -2046,7 +2059,7 @@ class datetime(date):
 
     def _realized_if_concrete_tzinfo(self):
         with NoTracing():
-            if isinstance(self._tzinfo, real_tzinfo):
+            if isinstance(self._tzinfo, any_tzinfo):
                 return realize(self)
             return self
 
@@ -2094,47 +2107,47 @@ class datetime(date):
     # Comparisons of datetime objects with other.
 
     def __eq__(self, other):
-        if isinstance(other, real_datetime):
+        if isinstance(other, any_datetime):
             return self._cmp(other, allow_mixed=True) == 0
-        elif not isinstance(other, real_date):
+        elif not isinstance(other, any_date):
             return NotImplemented
         else:
             return False
 
     def __le__(self, other):
-        if isinstance(other, real_datetime):
+        if isinstance(other, any_datetime):
             return self._cmp(other) <= 0
-        elif not isinstance(other, real_date):
+        elif not isinstance(other, any_date):
             return NotImplemented
         else:
             _cmperror(self, other)
 
     def __lt__(self, other):
-        if isinstance(other, real_datetime):
+        if isinstance(other, any_datetime):
             return self._cmp(other) < 0
-        elif not isinstance(other, real_date):
+        elif not isinstance(other, any_date):
             return NotImplemented
         else:
             _cmperror(self, other)
 
     def __ge__(self, other):
-        if isinstance(other, real_datetime):
+        if isinstance(other, any_datetime):
             return self._cmp(other) >= 0
-        elif not isinstance(other, real_date):
+        elif not isinstance(other, any_date):
             return NotImplemented
         else:
             _cmperror(self, other)
 
     def __gt__(self, other):
-        if isinstance(other, real_datetime):
+        if isinstance(other, any_datetime):
             return self._cmp(other) > 0
-        elif not isinstance(other, real_date):
+        elif not isinstance(other, any_date):
             return NotImplemented
         else:
             _cmperror(self, other)
 
     def _cmp(self, other, allow_mixed=False):
-        assert isinstance(other, real_datetime)
+        assert isinstance(other, any_datetime)
         mytz = self._tzinfo
         ottz = other.tzinfo
         myoff = otoff = None
@@ -2186,7 +2199,7 @@ class datetime(date):
 
     def __add__(self, other):
         """Add a datetime and a timedelta."""
-        if not isinstance(other, real_timedelta):
+        if not isinstance(other, any_timedelta):
             return NotImplemented
         delta = timedelta(
             self.toordinal(),
@@ -2209,8 +2222,8 @@ class datetime(date):
 
     def __sub__(self, other):
         """Subtract two datetimes, or a datetime and a timedelta."""
-        if not isinstance(other, real_datetime):
-            if isinstance(other, real_timedelta):
+        if not isinstance(other, any_datetime):
+            if isinstance(other, any_timedelta):
                 return self + -other
             return NotImplemented
 
@@ -2265,6 +2278,8 @@ class datetime(date):
         return real_datetime
 
 
+any_datetime = (datetime, real_datetime)
+
 datetime.min = datetime(1, 1, 1)  # type: ignore
 datetime.max = datetime(9999, 12, 31, 23, 59, 59, 999999)  # type: ignore
 datetime.resolution = timedelta(microseconds=1)  # type: ignore
@@ -2289,7 +2304,7 @@ class timezone(tzinfo):
     _Omitted = Omitted.value
 
     def __new__(cls, offset: real_timedelta, name: Union[str, Omitted] = _Omitted):
-        if not isinstance(offset, real_timedelta):
+        if not isinstance(offset, any_timedelta):
             raise TypeError("offset must be a timedelta")
         if name == cls._Omitted:
             if not offset:
@@ -2319,7 +2334,7 @@ class timezone(tzinfo):
         return (self._offset, self._name)
 
     def __eq__(self, other):
-        if isinstance(other, real_timezone):
+        if isinstance(other, any_timezone):
             return self.utcoffset(None) == other.utcoffset(None)
         return NotImplemented
 
@@ -2346,24 +2361,24 @@ class timezone(tzinfo):
         return self.tzname(None)
 
     def utcoffset(self, dt):
-        if isinstance(dt, real_datetime) or dt is None:
+        if isinstance(dt, any_datetime) or dt is None:
             return self._offset
         raise TypeError("utcoffset() argument must be a datetime instance" " or None")
 
     def tzname(self, dt):
-        if isinstance(dt, real_datetime) or dt is None:
+        if isinstance(dt, any_datetime) or dt is None:
             if self._name is None:
                 return self._name_from_offset(self._offset)
             return self._name
         raise TypeError("tzname() argument must be a datetime instance" " or None")
 
     def dst(self, dt):
-        if isinstance(dt, real_datetime) or dt is None:
+        if isinstance(dt, any_datetime) or dt is None:
             return None
         raise TypeError("dst() argument must be a datetime instance" " or None")
 
     def fromutc(self, dt):
-        if isinstance(dt, real_datetime):
+        if isinstance(dt, any_datetime):
             if dt.tzinfo is not self:
                 raise ValueError("fromutc: dt.tzinfo " "is not self")
             return dt + self._offset
@@ -2407,6 +2422,8 @@ class timezone(tzinfo):
         return real_timezone
 
 
+any_timezone = (timezone, real_timezone)
+
 timezone.utc = timezone._create(timedelta(0))  # type: ignore
 # bpo-37642: These attributes are rounded to the nearest minute for backwards
 # compatibility, even though the constructor will accept a wider range of

crosshair/libimpl/datetimelib_ch_test.py

@@ -6,7 +6,7 @@ from typing import Tuple, Union
 import pytest  # type: ignore
 
 from crosshair.core_and_libs import MessageType, analyze_function, run_checkables
-from crosshair.test_util import ResultComparison, compare_results
+from crosshair.test_util import ResultComparison, compare_results, compare_returns
 
 # crosshair: max_uninteresting_iterations=10
 
@@ -29,7 +29,7 @@ def check_datetimelib_lt(
         Tuple[timedelta, timedelta],
         Tuple[date, datetime],
         Tuple[datetime, datetime],
-    ]
+    ],
 ) -> ResultComparison:
     """post: _"""
     return compare_results(operator.lt, *p)
@@ -40,7 +40,7 @@ def check_datetimelib_add(
         Tuple[timedelta, timedelta],
         Tuple[date, timedelta],
         Tuple[timedelta, datetime],
-    ]
+    ],
 ) -> ResultComparison:
     """post: _"""
     return compare_results(operator.add, *p)
@@ -52,14 +52,14 @@ def check_datetimelib_subtract(
         Tuple[date, timedelta],
         Tuple[datetime, timedelta],
         Tuple[datetime, datetime],
-    ]
+    ],
 ) -> ResultComparison:
     """post: _"""
     return compare_results(operator.sub, *p)
 
 
 def check_datetimelib_str(
-    obj: Union[timedelta, timezone, date, time, datetime]
+    obj: Union[timedelta, timezone, date, time, datetime],
 ) -> ResultComparison:
     """post: _"""
     return compare_results(_invoker("__str__"), obj)
@@ -67,7 +67,7 @@ def check_datetimelib_str(
 
 def check_datetimelib_repr(
     # TODO: re-enable time, datetime repr checking after fixing in Python 3.11
-    obj: Union[timedelta, timezone, date]
+    obj: Union[timedelta, timezone, date],
 ) -> ResultComparison:
     """post: _"""
     return compare_results(_invoker("__repr__"), obj)
@@ -87,7 +87,7 @@ def check_timedelta_new(
     """post: _"""
     if days % 1 != 0 or secs % 1 != 0 or microsecs % 1 != 0:
         pass
-    return compare_results(lambda *a: timedelta(*a), days, secs, microsecs)
+    return compare_returns(lambda *a: timedelta(*a), days, secs, microsecs)
 
 
 def check_timedelta_bool(td: timedelta) -> ResultComparison:
@@ -280,6 +280,11 @@ def check_datetime_ctime(dt: datetime) -> ResultComparison:
 
 def check_datetime_strftime(dt: datetime, fmt: str) -> ResultComparison:
     """post: _"""
+    # not using skipIf because this is invoked via `test_builtin`:
+    if sys.version_info < (3, 13):
+        # strftime null character handling aligned between python and C
+        # implementations in https://github.com/python/cpython/pull/125657
+        return True
     return compare_results(_invoker("strftime"), dt, fmt)
 
 

crosshair/libimpl/datetimelib_test.py

@@ -2,8 +2,7 @@ import datetime
 
 import pytest
 
-from crosshair.options import AnalysisOptionSet
-from crosshair.statespace import CANNOT_CONFIRM, EXEC_ERR, POST_FAIL
+from crosshair.statespace import CONFIRMED, EXEC_ERR, POST_FAIL
 from crosshair.test_util import check_states
 
 
@@ -63,21 +62,21 @@ def test_timedelta_fail() -> None:
     check_states(f, POST_FAIL)
 
 
-def test_date_plus_delta_unknown() -> None:
+def test_date_plus_delta_fail() -> None:
     def f(delta: datetime.timedelta) -> datetime.date:
         """
-        post: _.year != -9999
+        post: _.year != 2033
         raises: OverflowError
         """
         return datetime.date(2000, 1, 1) + delta
 
-    check_states(f, CANNOT_CONFIRM)
+    check_states(f, POST_FAIL)
 
 
 def test_date_plus_delta_overflow_err() -> None:
     def f(delta: datetime.timedelta) -> datetime.date:
         """
-        post: _.year != -9999
+        post: True
         """
         return datetime.date(2000, 1, 1) + delta