zopefoundation__DateTime-62

{
  "status": "ok",
  "stdout": "src/DateTime/tests/test_datetime.py:264:    def test_pickle(self):\nsrc/DateTime/tests/test_datetime.py:271:    def test_pickle_with_tz(self):\nsrc/DateTime/tests/test_datetime.py:278:    def test_pickle_asdatetime_with_tz(self):\nsrc/DateTime/tests/test_datetime.py:285:    def test_pickle_with_numerical_tz(self):\nsrc/DateTime/tests/test_datetime.py:295:    def test_pickle_with_micros(self):\nsrc/DateTime/tests/test_datetime.py:302:    def test_pickle_old(self):\nsrc/DateTime/tests/test_datetime.py:322:    def test_pickle_old_without_micros(self):\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "filepath": "src/DateTime/DateTime.py",
  "content": "from time import gmtime\nfrom time import localtime\nfrom time import time\nfrom time import timezone\nfrom time import tzname\n\nfrom zope.interface import implementer\n\nfrom .interfaces import DateError\nfrom .interfaces import DateTimeError\nfrom .interfaces import IDateTime\nfrom .interfaces import SyntaxError\nfrom .interfaces import TimeError\nfrom .pytz_support import PytzCache\n\n\nbasestring = str\nlong = int\nexplicit_unicode_type = type(None)\n\ndefault_datefmt = None\n\n\ndef getDefaultDateFormat():\n    global default_datefmt\n    if default_datefmt is None:\n        try:\n            from App.config import getConfiguration\n            default_datefmt = getConfiguration().datetime_format\n            return default_datefmt\n        except Exception:\n            return 'us'\n    else:\n        return default_datefmt\n\n\n# To control rounding errors, we round system time to the nearest\n# microsecond.  Then delicate calculations can rely on the fact that the\n# maximum precision that needs to be preserved is known.\n_system_time = time\n\n\ndef time():\n    return round(_system_time(), 6)\n\n\n# Determine machine epoch\ntm = ((0, 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334),\n      (0, 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335))\nyr, mo, dy, hr, mn, sc = gmtime(0)[:6]\ni = int(yr - 1)\nto_year = int(i * 365 + i // 4 - i // 100 + i // 400 - 693960.0)\nto_month = tm[yr % 4 == 0 and (yr % 100 != 0 or yr % 400 == 0)][mo]\nEPOCH = ((to_year + to_month + dy +\n          (hr / 24.0 + mn / 1440.0 + sc / 86400.0)) * 86400)\njd1901 = 2415385\n\n_TZINFO = PytzCache()\n\nINT_PATTERN = re.compile(r'([0-9]+)')\nFLT_PATTERN = re.compile(r':([0-9]+\\.[0-9]+)')",
  "start_line": 20,
  "end_line": 80,
  "total_lines": 1946,
  "is_truncated": false
}

{
  "status": "ok",
  "stdout": "375:class DateTime:\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "filepath": "src/DateTime/DateTime.py",
  "content": "class DateTime:\n    \"\"\"DateTime objects represent instants in time and provide\n       interfaces for controlling its representation without\n       affecting the absolute value of the object.\n\n       DateTime objects may be created from a wide variety of string\n       or numeric data, or may be computed from other DateTime objects.\n       DateTimes support the ability to convert their representations\n       to many major timezones, as well as the ability to create a\n       DateTime object in the context of a given timezone.\n\n       DateTime objects provide partial numerical behavior:\n\n          - Two date-time objects can be subtracted to obtain a time,\n            in days between the two.\n\n          - A date-time object and a positive or negative number may\n            be added to obtain a new date-time object that is the given\n            number of days later than the input date-time object.\n\n          - A positive or negative number and a date-time object may\n            be added to obtain a new date-time object that is the given\n            number of days later than the input date-time object.\n\n          - A positive or negative number may be subtracted from a\n            date-time object to obtain a new date-time object that is\n            the given number of days earlier than the input date-time\n            object.\n\n        DateTime objects may be converted to integer, long, or float\n        numbers of days since January 1, 1901, using the standard int,\n        long, and float functions (Compatibility Note: int, long and\n        float return the number of days since 1901 in GMT rather than\n        local machine timezone). DateTime objects also provide access\n        to their value in a float format usable with the Python time\n        module, provided that the value of the object falls in the\n        range of the epoch-based time module, and as a datetime.datetime\n        object.\n\n        A DateTime object should be considered immutable; all conversion\n        and numeric operations return a new DateTime object rather than\n        modify the current object.\"\"\"\n\n    # For security machinery:\n    __roles__ = None\n    __allow_access_to_unprotected_subobjects__ = 1\n\n    # Limit the amount of instance attributes\n    __slots__ = (\n        '_timezone_naive',\n        '_tz',\n        '_dayoffset',\n        '_year',\n        '_month',\n        '_day',\n        '_hour',\n        '_minute',\n        '_second',\n        '_nearsec',\n        '_d',\n        '_micros',\n        'time',\n    )\n\n    def __init__(self, *args, **kw):\n        \"\"\"Return a new date-time object\"\"\"\n        try:\n            return self._parse_args(*args, **kw)\n        except (DateError, TimeError, DateTimeError):\n            raise\n        except Exception:\n            raise SyntaxError('Unable to parse {}, {}'.format(args, kw))\n\n    def __getstate__(self):\n        # We store a float of _micros, instead of the _micros long, as we most\n        # often don't have any sub-second resolution and can save those bytes\n        return (self._micros / 1000000.0,\n                getattr(self, '_timezone_naive', False),\n                self._tz)\n\n    def __setstate__(self, value):\n        if isinstance(value, tuple):\n            self._parse_args(value[0], value[2])\n            self._micros = long(value[0] * 1000000)\n            self._timezone_naive = value[1]\n        else:\n            for k, v in value.items():\n                if k in self.__slots__:\n                    setattr(self, k, v)\n            # BBB: support for very old DateTime pickles\n            if '_micros' not in value:\n                self._micros = long(value['_t'] * 1000000)\n            if '_timezone_naive' not in value:\n                self._timezone_naive = False\n\n    def _parse_args(self, *args, **kw):\n        \"\"\"Return a new date-time object.\n\n        A DateTime object always maintains its value as an absolute\n        UTC time, and is represented in the context of some timezone\n        based on the arguments used to create the object. A DateTime\n        object's methods return values based on the timezone context.\n\n        Note that in all cases the local machine timezone is used for\n        representation if no timezone is specified.\n\n        DateTimes may be created with zero to seven arguments.\n\n          - If the function is called with no arguments or with None,\n            then the current date/time is returned, represented in the\n            timezone of the local machine.\n\n          - If the function is invoked with a single string argument\n            which is a recognized timezone name, an object representing\n            the current time is returned, represented in the specified\n            timezone.\n\n          - If the function is invoked with a single string argument\n            representing a valid date/time, an object representing\n            that date/time will be returned.\n\n            As a general rule, any date-time representation that is\n            recognized and unambiguous to a resident of North America\n            is acceptable. The reason for this qualification is that\n            in North America, a date like: 2/1/1994 is interpreted\n            as February 1, 1994, while in some parts of the world,",
  "start_line": 375,
  "end_line": 500,
  "total_lines": 1946,
  "is_truncated": false
}

{
  "status": "ok",
  "stdout": "Original _micros: 2198556426235027\nUnpickled _micros: 2198556426235026\nFAILURE: 2198556426235027 != 2198556426235026\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "filepath": "src/DateTime/DateTime.py",
  "content": "            as February 1, 1994, while in some parts of the world,\n            it is interpreted as January 2, 1994.\n\n            A date/time string consists of two components, a date\n            component and an optional time component, separated by one\n            or more spaces. If the time component is omitted, 12:00am is\n            assumed. Any recognized timezone name specified as the final\n            element of the date/time string will be used for computing\n            the date/time value. If you create a DateTime with the\n            string 'Mar 9, 1997 1:45pm US/Pacific', the value will\n            essentially be the same as if you had captured time.time()\n            at the specified date and time on a machine in that timezone:\n\n            <pre>\n            e = DateTime('US/Eastern')\n            # returns current date/time, represented in US/Eastern.\n\n            x = DateTime('1997/3/9 1:45pm')\n            # returns specified time, represented in local machine zone.\n\n            y = DateTime('Mar 9, 1997 13:45:00')\n            # y is equal to x\n            </pre>\n\n            The date component consists of year, month, and day\n            values. The year value must be a one-, two-, or\n            four-digit integer. If a one- or two-digit year is\n            used, the year is assumed to be in the twentieth\n            century. The month may be an integer, from 1 to 12, a\n            month name, or a month abbreviation, where a period may\n            optionally follow the abbreviation. The day must be an\n            integer from 1 to the number of days in the month. The\n            year, month, and day values may be separated by\n            periods, hyphens, forward slashes, or spaces. Extra\n            spaces are permitted around the delimiters. Year,\n            month, and day values may be given in any order as long\n            as it is possible to distinguish the components. If all\n            three components are numbers that are less than 13,\n            then a month-day-year ordering is assumed.\n\n            The time component consists of hour, minute, and second\n            values separated by colons.  The hour value must be an\n            integer between 0 and 23 inclusively. The minute value\n            must be an integer between 0 and 59 inclusively. The\n            second value may be an integer value between 0 and\n            59.999 inclusively. The second value or both the minute\n            and second values may be omitted. The time may be\n            followed by am or pm in upper or lower case, in which\n            case a 12-hour clock is assumed.\n\n            New in Zope 2.4:\n            The DateTime constructor automatically detects and handles\n            ISO8601 compliant dates (YYYY-MM-DDThh:ss:mmTZD).\n\n            New in Zope 2.9.6:\n            The existing ISO8601 parser was extended to support almost\n            the whole ISO8601 specification. New formats includes:\n\n            <pre>\n            y = DateTime('1993-045')\n            # returns the 45th day from 1993, which is 14th February\n\n            w = DateTime('1993-W06-7')\n            # returns the 7th day from the 6th week from 1993, which\n            # is also 14th February\n            </pre>\n\n            See http://en.wikipedia.org/wiki/ISO_8601 for full specs.\n\n            Note that the Zope DateTime parser assumes timezone naive ISO\n            strings to be in UTC rather than local time as specified.\n\n          - If the DateTime function is invoked with a single numeric\n            argument, the number is assumed to be a floating point value\n            such as that returned by time.time().\n\n            A DateTime object is returned that represents the GMT value\n            of the time.time() float represented in the local machine's\n            timezone.\n\n          - If the DateTime function is invoked with a single argument\n            that is a DateTime instance, a copy of the passed object will\n            be created.\n\n          - New in 2.11:\n            The DateTime function may now be invoked with a single argument\n            that is a datetime.datetime instance. DateTimes may be converted\n            back to datetime.datetime objects with asdatetime().\n            DateTime instances may be converted to a timezone naive\n            datetime.datetime in UTC with utcdatetime().\n\n          - If the function is invoked with two numeric arguments, then\n            the first is taken to be an integer year and the second\n            argument is taken to be an offset in days from the beginning\n            of the year, in the context of the local machine timezone.\n\n            The date-time value returned is the given offset number of\n            days from the beginning of the given year, represented in\n            the timezone of the local machine. The offset may be positive\n            or negative.\n\n            Two-digit years are assumed to be in the twentieth\n            century.\n\n          - If the function is invoked with two arguments, the first\n            a float representing a number of seconds past the epoch\n            in gmt (such as those returned by time.time()) and the\n            second a string naming a recognized timezone, a DateTime\n            with a value of that gmt time will be returned, represented\n            in the given timezone.\n\n            <pre>\n            import time\n            t = time.time()\n\n            now_east = DateTime(t,'US/Eastern')\n            # Time t represented as US/Eastern\n\n            now_west = DateTime(t,'US/Pacific')\n            # Time t represented as US/Pacific\n\n            # now_east == now_west\n            # only their representations are different\n            </pre>\n\n          - If the function is invoked with three or more numeric\n            arguments, then the first is taken to be an integer\n            year, the second is taken to be an integer month, and\n            the third is taken to be an integer day. If the\n            combination of values is not valid, then a\n            DateError is raised. Two-digit years are assumed\n            to be in the twentieth century. The fourth, fifth, and\n            sixth arguments specify a time in hours, minutes, and\n            seconds; hours and minutes should be positive integers\n            and seconds is a positive floating point value, all of\n            these default to zero if not given. An optional string may\n            be given as the final argument to indicate timezone (the\n            effect of this is as if you had taken the value of time.time()\n            at that time on a machine in the specified timezone).\n\n            New in Zope 2.7:\n            A new keyword parameter \"datefmt\" can be passed to the\n            constructor. If set to \"international\", the constructor\n            is forced to treat ambiguous dates as \"days before month\n            before year\". This useful if you need to parse non-US\n            dates in a reliable way\n\n        In any case that a floating point number of seconds is given\n        or derived, it's rounded to the nearest millisecond.\n",
  "start_line": 500,
  "end_line": 649,
  "total_lines": 1946,
  "is_truncated": true
}

{
  "status": "ok",
  "stdout": "470:    def _parse_args(self, *args, **kw):\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "filepath": "src/DateTime/DateTime.py",
  "content": "        If a string argument passed to the DateTime constructor cannot be\n        parsed, it will raise DateTime.SyntaxError. Invalid date components\n        will raise a DateError, while invalid time or timezone components\n        will raise a DateTimeError.\n\n        The module function Timezones() will return a list of the (common)\n        timezones recognized by the DateTime module. Recognition of\n        timezone names is case-insensitive.\n        \"\"\"\n\n        datefmt = kw.get('datefmt', getDefaultDateFormat())\n        d = t = s = None\n        ac = len(args)\n        microsecs = None\n\n        if ac == 10:\n            # Internal format called only by DateTime\n            yr, mo, dy, hr, mn, sc, tz, t, d, s = args\n        elif ac == 11:\n            # Internal format that includes milliseconds (from the epoch)\n            yr, mo, dy, hr, mn, sc, tz, t, d, s, millisecs = args\n            microsecs = millisecs * 1000\n\n        elif ac == 12:\n            # Internal format that includes microseconds (from the epoch) and a\n            # flag indicating whether this was constructed in a timezone naive\n            # manner\n            yr, mo, dy, hr, mn, sc, tz, t, d, s, microsecs, tznaive = args\n            if tznaive is not None:  # preserve this information\n                self._timezone_naive = tznaive\n\n        elif not args or (ac and args[0] is None):\n            # Current time, to be displayed in local timezone\n            t = time()\n            lt = safelocaltime(t)\n            tz = self.localZone(lt)\n            ms = (t - math.floor(t))\n            s, d = _calcSD(t)\n            yr, mo, dy, hr, mn, sc = lt[:6]\n            sc = sc + ms\n            self._timezone_naive = False\n\n        elif ac == 1:\n            arg = args[0]\n\n            if arg == '':\n                raise SyntaxError(arg)\n\n            if isinstance(arg, DateTime):\n                \"\"\"Construct a new DateTime instance from a given\n                DateTime instance.\n                \"\"\"\n                t = arg.timeTime()\n                s, d = _calcSD(t)\n                yr, mo, dy, hr, mn, sc, tz = arg.parts()\n\n            elif isinstance(arg, datetime):\n                yr, mo, dy, hr, mn, sc, numerictz, tznaive = \\\n                    self._parse_iso8601_preserving_tznaive(arg.isoformat())\n                if arg.tzinfo is None:\n                    self._timezone_naive = True\n                    tz = None\n                else:\n                    self._timezone_naive = False\n                    # if we have a pytz tzinfo, use the `zone` attribute\n                    # as a key\n                    tz = getattr(arg.tzinfo, 'zone', numerictz)\n                ms = sc - math.floor(sc)\n                x = _calcDependentSecond2(yr, mo, dy, hr, mn, sc)\n\n                if tz:\n                    try:\n                        zone = _TZINFO[tz]\n                    except DateTimeError:\n                        try:\n                            zone = _TZINFO[numerictz]\n                        except DateTimeError:\n                            raise DateTimeError(\n                                'Unknown time zone in date: %s' % arg)\n                    tz = zone.tzinfo.zone\n                else:\n                    tz = self._calcTimezoneName(x, ms)\n                s, d, t, microsecs = _calcIndependentSecondEtc(tz, x, ms)\n\n            elif (isinstance(arg, basestring) and\n                  arg.lower() in _TZINFO._zidx):\n                # Current time, to be displayed in specified timezone\n                t, tz = time(), _TZINFO._zmap[arg.lower()]\n                ms = (t - math.floor(t))\n                # Use integer arithmetic as much as possible.\n                s, d = _calcSD(t)\n                x = _calcDependentSecond(tz, t)\n                yr, mo, dy, hr, mn, sc = _calcYMDHMS(x, ms)\n\n            elif isinstance(arg, basestring):\n                # Date/time string\n                iso8601 = iso8601Match(arg.strip())\n                fields_iso8601 = iso8601 and iso8601.groupdict() or {}\n                if fields_iso8601 and not fields_iso8601.get('garbage'):\n                    yr, mo, dy, hr, mn, sc, tz, tznaive = \\\n                        self._parse_iso8601_preserving_tznaive(arg)\n                    self._timezone_naive = tznaive\n                else:\n                    yr, mo, dy, hr, mn, sc, tz = self._parse(arg, datefmt)\n\n                if not self._validDate(yr, mo, dy):\n                    raise DateError('Invalid date: %s' % arg)\n                if not self._validTime(hr, mn, int(sc)):\n                    raise TimeError('Invalid time: %s' % arg)\n                ms = sc - math.floor(sc)\n                x = _calcDependentSecond2(yr, mo, dy, hr, mn, sc)\n\n                if tz:\n                    try:\n                        tz = _TZINFO._zmap[tz.lower()]\n                    except KeyError:\n                        if numericTimeZoneMatch(tz) is None:\n                            raise DateTimeError(\n                                'Unknown time zone in date: %s' % arg)\n                else:\n                    tz = self._calcTimezoneName(x, ms)\n                s, d, t, microsecs = _calcIndependentSecondEtc(tz, x, ms)\n\n            else:\n                # Seconds from epoch, gmt\n                t = arg\n                lt = safelocaltime(t)\n                tz = self.localZone(lt)\n                ms = (t - math.floor(t))\n                s, d = _calcSD(t)\n                yr, mo, dy, hr, mn, sc = lt[:6]\n                sc = sc + ms\n\n        elif ac == 2:\n            if isinstance(args[1], basestring):\n                # Seconds from epoch (gmt) and timezone\n                t, tz = args\n                ms = (t - math.floor(t))\n                try:\n                    tz = _TZINFO._zmap[tz.lower()]\n                except KeyError:\n                    if numericTimeZoneMatch(tz) is None:\n                        raise DateTimeError('Unknown time zone: %s' % tz)\n                # Use integer arithmetic as much as possible.\n                s, d = _calcSD(t)\n                x = _calcDependentSecond(tz, t)\n                yr, mo, dy, hr, mn, sc = _calcYMDHMS(x, ms)\n            else:\n                # Year, julian expressed in local zone\n                t = time()",
  "start_line": 650,
  "end_line": 799,
  "total_lines": 1946,
  "is_truncated": true
}

{
  "status": "ok",
  "stdout": "458:            self._micros = long(value[0] * 1000000)\n466:                self._micros = long(value['_t'] * 1000000)\n863:        self._micros = microsecs\n1297:            return self._micros == long(t * 1000000)\n1299:            return self._micros == t._micros\n1301:            return self._micros == t\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "filepath": "src/DateTime/DateTime.py",
  "content": "\n    __ge__ = greaterThanEqualTo\n\n    def equalTo(self, t):\n        \"\"\"Compare this DateTime object to another DateTime object\n        OR a floating point number such as that which is returned\n        by the Python time module.\n\n        Returns true if the object represents a date/time equal to\n        the specified DateTime or time module style time.\n\n        Revised to give more correct results through comparison of\n        long integer microseconds.\n        \"\"\"\n        if t is None:\n            return False\n        if isinstance(t, (float, int)):\n            return self._micros == long(t * 1000000)\n        try:\n            return self._micros == t._micros\n        except AttributeError:\n            return self._micros == t\n\n    def notEqualTo(self, t):\n        \"\"\"Compare this DateTime object to another DateTime object\n        OR a floating point number such as that which is returned\n        by the Python time module.\n\n        Returns true if the object represents a date/time not equal\n        to the specified DateTime or time module style time.\n",
  "start_line": 1280,
  "end_line": 1310,
  "total_lines": 1946,
  "is_truncated": false
}

{
  "status": "ok",
  "stdout": "213:    return fset + long(math.floor(t)) + long(EPOCH) - 86400\n220:    x = long(_julianday(yr, mo, dy) - jd1901) * 86400 + ss\n228:    nearTime = x - fsetAtEpoch - long(EPOCH) + 86400 + ms\n231:    fset = long(_tzoffset(tz, nearTime))\n233:    t = x - fset - long(EPOCH) + 86400 + ms\n235:        long(round(ms * 1000000.0)) - long(EPOCH * 1000000.0)\n262:    y, m, d = long(yr), long(mo), long(dy)\n285:    j = long(j)\n458:            self._micros = long(value[0] * 1000000)\n466:                self._micros = long(value['_t'] * 1000000)\n808:                x = long(x_floor)\n862:            microsecs = long(round(t * 1000000.0))\n882:        nearTime = x - fsetAtEpoch - long(EPOCH) + 86400 + ms\n894:            nearTime = x - fsetAtEpoch - long(EPOCH) + 86400 + ms\n1252:            return self._micros > long(t * 1000000)\n1275:            return self._micros >= long(t * 1000000)\n1297:            return self._micros == long(t * 1000000)\n1344:            return self._micros < long(t * 1000000)\n1366:            return self._micros <= long(t * 1000000)\n1751:        d = (tmicros + long(EPOCH * 1000000)) / 86400000000.0\n1811:        return long(self.micros() // 1000000)  # pragma: PY2\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "stdout": "t: 2198556426.235027\nlong(t * 1000000): 2198556426235026\nround(t * 1000000): 2198556426235027\n",
  "stderr": "",
  "exit_code": 0
}