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/tests/test_datetime.py",
  "content": "            self.assertFalse(dt.lessThanEqualTo(None))\n            self.assertTrue(dt.notEqualTo(None))\n            self.assertFalse(dt.equalTo(None))\n\n    def test_pickle(self):\n        dt = DateTime()\n        data = pickle.dumps(dt, 1)\n        new = pickle.loads(data)\n        for key in DateTime.__slots__:\n            self.assertEqual(getattr(dt, key), getattr(new, key))\n\n    def test_pickle_with_tz(self):\n        dt = DateTime('2002/5/2 8:00am GMT+8')\n        data = pickle.dumps(dt, 1)\n        new = pickle.loads(data)\n        for key in DateTime.__slots__:\n            self.assertEqual(getattr(dt, key), getattr(new, key))\n\n    def test_pickle_asdatetime_with_tz(self):\n        dt = DateTime('2002/5/2 8:00am GMT+8')\n        data = pickle.dumps(dt.asdatetime(), 1)\n        new = DateTime(pickle.loads(data))\n        for key in DateTime.__slots__:\n            self.assertEqual(getattr(dt, key), getattr(new, key))\n\n    def test_pickle_with_numerical_tz(self):\n        for dt_str in ('2007/01/02 12:34:56.789 +0300',\n                       '2007/01/02 12:34:56.789 +0430',\n                       '2007/01/02 12:34:56.789 -1234'):\n            dt = DateTime(dt_str)\n            data = pickle.dumps(dt, 1)\n            new = pickle.loads(data)\n            for key in DateTime.__slots__:\n                self.assertEqual(getattr(dt, key), getattr(new, key))\n\n    def test_pickle_with_micros(self):\n        dt = DateTime('2002/5/2 8:00:14.123 GMT+8')\n        data = pickle.dumps(dt, 1)\n        new = pickle.loads(data)\n        for key in DateTime.__slots__:\n            self.assertEqual(getattr(dt, key), getattr(new, key))\n\n    def test_pickle_old(self):\n        dt = DateTime('2002/5/2 8:00am GMT+0')\n        data = (\n            '(cDateTime.DateTime\\nDateTime\\nq\\x01Noq\\x02}q\\x03(U\\x05'\n            '_amonq\\x04U\\x03Mayq\\x05U\\x05_adayq\\x06U\\x03Thuq\\x07U\\x05_pmonq'\n            '\\x08h\\x05U\\x05_hourq\\tK\\x08U\\x05_fmonq\\nh\\x05U\\x05_pdayq\\x0bU'\n            '\\x04Thu.q\\x0cU\\x05_fdayq\\rU\\x08Thursdayq\\x0eU\\x03_pmq\\x0fU\\x02amq'\n            '\\x10U\\x02_tq\\x11GA\\xcehy\\x00\\x00\\x00\\x00U\\x07_minuteq\\x12K\\x00U'\n            '\\x07_microsq\\x13L1020326400000000L\\nU\\x02_dq\\x14G@\\xe2\\x12j\\xaa'",
  "start_line": 260,
  "end_line": 310,
  "total_lines": 746,
  "is_truncated": false
}

{
  "status": "ok",
  "filepath": "src/DateTime/DateTime.py",
  "content": "##############################################################################\n#\n# Copyright (c) 2002 Zope Foundation and Contributors.\n#\n# This software is subject to the provisions of the Zope Public License,\n# Version 2.1 (ZPL).  A copy of the ZPL should accompany this distribution.\n# THIS SOFTWARE IS PROVIDED \"AS IS\" AND ANY AND ALL EXPRESS OR IMPLIED\n# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\n# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS\n# FOR A PARTICULAR PURPOSE\n#\n##############################################################################\n\nimport copyreg as copy_reg\nimport math\nimport re\nfrom datetime import datetime\nfrom time import altzone\nfrom time import daylight\nfrom 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]+)')\nNAME_PATTERN = re.compile(r'([a-zA-Z]+)', re.I)\nSPACE_CHARS = ' \\t\\n'\nDELIMITERS = '-/.:,+'\n\n_MONTH_LEN = ((0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31),\n              (0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31))\n_MONTHS = ('', 'January', 'February', 'March', 'April', 'May', 'June',\n           'July', 'August', 'September', 'October', 'November', 'December')\n_MONTHS_A = ('', 'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun',\n             'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec')\n_MONTHS_P = ('', 'Jan.', 'Feb.', 'Mar.', 'Apr.', 'May', 'June',\n             'July', 'Aug.', 'Sep.', 'Oct.', 'Nov.', 'Dec.')\n_MONTHMAP = {'january': 1, 'jan': 1,\n             'february': 2, 'feb': 2,\n             'march': 3, 'mar': 3,\n             'april': 4, 'apr': 4,\n             'may': 5,\n             'june': 6, 'jun': 6,\n             'july': 7, 'jul': 7,\n             'august': 8, 'aug': 8,",
  "start_line": 1,
  "end_line": 100,
  "total_lines": 1946,
  "is_truncated": false
}

{
  "status": "ok",
  "filepath": "src/DateTime/DateTime.py",
  "content": "def _tzoffset(tz, t):\n    \"\"\"Returns the offset in seconds to GMT from a specific timezone (tz) at\n    a specific time (t).  NB! The _tzoffset result is the same same sign as\n    the time zone, i.e. GMT+2 has a 7200 second offset. This is the opposite\n    sign of time.timezone which (confusingly) is -7200 for GMT+2.\"\"\"\n    try:\n        return _TZINFO[tz].info(t)[0]\n    except Exception:\n        if numericTimeZoneMatch(tz) is not None:\n            return int(tz[0:3]) * 3600 + int(tz[0] + tz[3:5]) * 60\n        else:\n            return 0  # ??\n\n\ndef _correctYear(year):\n    # Y2K patch.\n    if year >= 0 and year < 100:\n        # 00-69 means 2000-2069, 70-99 means 1970-1999.\n        if year < 70:\n            year = 2000 + year\n        else:\n            year = 1900 + year\n    return year\n\n\ndef safegmtime(t):\n    '''gmtime with a safety zone.'''\n    try:\n        return gmtime(t)\n    except (ValueError, OverflowError):\n        raise TimeError('The time %f is beyond the range of this Python '\n                        'implementation.' % float(t))\n\n\ndef safelocaltime(t):\n    '''localtime with a safety zone.'''\n    try:\n        return localtime(t)\n    except (ValueError, OverflowError):\n        raise TimeError('The time %f is beyond the range of this Python '\n                        'implementation.' % float(t))\n\n\ndef _tzoffset2rfc822zone(seconds):\n    \"\"\"Takes an offset, such as from _tzoffset(), and returns an rfc822\n       compliant zone specification. Please note that the result of\n       _tzoffset() is the negative of what time.localzone and time.altzone is.\n    \"\"\"\n    return \"%+03d%02d\" % divmod((seconds // 60), 60)\n\n\ndef _tzoffset2iso8601zone(seconds):\n    \"\"\"Takes an offset, such as from _tzoffset(), and returns an ISO 8601\n       compliant zone specification. Please note that the result of\n       _tzoffset() is the negative of what time.localzone and time.altzone is.\n    \"\"\"\n    return \"%+03d:%02d\" % divmod((seconds // 60), 60)\n\n\ndef Timezones():\n    \"\"\"Return the list of recognized timezone names\"\"\"\n    return sorted(list(PytzCache._zmap.values()))\n\n\nclass strftimeFormatter:\n\n    def __init__(self, dt, format):\n        self.dt = dt\n        self.format = format\n\n    def __call__(self):\n        return self.dt.strftime(self.format)\n\n\n@implementer(IDateTime)\nclass 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",
  "start_line": 300,
  "end_line": 449,
  "total_lines": 1946,
  "is_truncated": true
}

{
  "status": "ok",
  "filepath": "src/DateTime/DateTime.py",
  "content": "        \"\"\"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):",
  "start_line": 440,
  "end_line": 470,
  "total_lines": 1946,
  "is_truncated": false
}

{
  "status": "ok",
  "stdout": "435:        '_micros',\n449:        # We store a float of _micros, instead of the _micros long, as we most\n451:        return (self._micros / 1000000.0,\n458:            self._micros = long(value[0] * 1000000)\n465:            if '_micros' not in value:\n466:                self._micros = long(value['_t'] * 1000000)\n859:        # self._micros is the time since the epoch\n863:        self._micros = microsecs\n1131:        return self._micros / 1000000.0\n1252:            return self._micros > long(t * 1000000)\n1254:            return self._micros > t._micros\n1256:            return self._micros > t\n1275:            return self._micros >= long(t * 1000000)\n1277:            return self._micros >= t._micros\n1279:            return self._micros >= t\n1297:            return self._micros == long(t * 1000000)\n1299:            return self._micros == t._micros\n1301:            return self._micros == t\n1325:        return (self._micros, self._tz) == (t._micros, t._tz)\n1344:            return self._micros < long(t * 1000000)\n1346:            return self._micros < t._micros\n1348:            return self._micros < t\n1366:            return self._micros <= long(t * 1000000)\n1368:            return self._micros <= t._micros\n1370:            return self._micros <= t\n1528:        return self._micros // 1000\n1532:        return self._micros\n1820:        return self._micros / 1000000.0\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "stdout": "Original _micros: 2198556420000000\nNew _micros:      2198556420000000\nSUCCESS\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "stdout": "Original _micros: 2198556426235027\nNew _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",
  "start_line": 500,
  "end_line": 600,
  "total_lines": 1946,
  "is_truncated": false
}

{
  "status": "ok",
  "filepath": "src/DateTime/DateTime.py",
  "content": "                lt = safelocaltime(t)\n                tz = self.localZone(lt)\n                yr, jul = args\n                yr = _correctYear(yr)\n                d = (_julianday(yr, 1, 0) - jd1901) + jul\n                x_float = d * 86400.0\n                x_floor = math.floor(x_float)\n                ms = x_float - x_floor\n                x = long(x_floor)\n                yr, mo, dy, hr, mn, sc = _calcYMDHMS(x, ms)\n                s, d, t, microsecs = _calcIndependentSecondEtc(tz, x, ms)\n        else:\n            # Explicit format\n            yr, mo, dy = args[:3]\n            hr, mn, sc, tz = 0, 0, 0, 0\n            yr = _correctYear(yr)\n            if not self._validDate(yr, mo, dy):\n                raise DateError('Invalid date: {}'.format(args))\n            args = args[3:]\n            if args:\n                hr, args = args[0], args[1:]\n                if args:\n                    mn, args = args[0], args[1:]\n                    if args:\n                        sc, args = args[0], args[1:]\n                        if args:\n                            tz, args = args[0], args[1:]\n                            if args:\n                                raise DateTimeError('Too many arguments')\n            if not self._validTime(hr, mn, sc):\n                raise TimeError('Invalid time: %s' % repr(args))\n\n            x = _calcDependentSecond2(yr, mo, dy, hr, mn, sc)\n            ms = sc - math.floor(sc)\n            if tz:\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            else:\n                # Get local time zone name\n                tz = self._calcTimezoneName(x, ms)\n            s, d, t, microsecs = _calcIndependentSecondEtc(tz, x, ms)\n\n        self._dayoffset = int((_julianday(yr, mo, dy) + 2) % 7)\n        # Round to nearest microsecond in platform-independent way. You\n        # cannot rely on C sprintf (Python '%') formatting to round\n        # consistently; doing it ourselves ensures that all but truly\n        # horrid C sprintf implementations will yield the same result\n        # cross-platform, provided the format asks for exactly 6 digits after\n        # the decimal point.\n        sc = round(sc, 6)\n        if sc >= 60.0:  # can happen if, e.g., orig sc was 59.9999999\n            sc = 59.999999\n        self._nearsec = math.floor(sc)\n        self._year, self._month, self._day = yr, mo, dy\n        self._hour, self._minute, self._second = hr, mn, sc\n        self.time, self._d, self._tz = s, d, tz\n        # self._micros is the time since the epoch\n        # in long integer microseconds.\n        if microsecs is None:\n            microsecs = long(round(t * 1000000.0))\n        self._micros = microsecs\n\n    def localZone(self, ltm=None):\n        '''Returns the time zone on the given date.  The time zone\n        can change according to daylight savings.'''\n        if not _multipleZones:\n            return _localzone0\n        if ltm is None:\n            ltm = localtime(time())\n        isDST = ltm[8]\n        lz = isDST and _localzone1 or _localzone0\n        return lz\n\n    def _calcTimezoneName(self, x, ms):\n        # Derive the name of the local time zone at the given\n        # timezone-dependent second.\n        if not _multipleZones:\n            return _localzone0\n        fsetAtEpoch = _tzoffset(_localzone0, 0.0)\n        nearTime = x - fsetAtEpoch - long(EPOCH) + 86400 + ms\n        # nearTime is within an hour of being correct.\n        try:\n            ltm = safelocaltime(nearTime)\n        except BaseException:\n            # We are beyond the range of Python's date support.\n            # Hopefully we can assume that daylight savings schedules\n            # repeat every 28 years.  Calculate the name of the\n            # time zone using a supported range of years.\n            yr, mo, dy, hr, mn, sc = _calcYMDHMS(x, 0)\n            yr = ((yr - 1970) % 28) + 1970\n            x = _calcDependentSecond2(yr, mo, dy, hr, mn, sc)\n            nearTime = x - fsetAtEpoch - long(EPOCH) + 86400 + ms\n\n            # nearTime might still be negative if we are east of Greenwich.\n            # But we can assume on 1969/12/31 were no timezone changes.\n            nearTime = max(0, nearTime)\n\n            ltm = safelocaltime(nearTime)",
  "start_line": 800,
  "end_line": 900,
  "total_lines": 1946,
  "is_truncated": false
}

{
  "status": "ok",
  "stdout": "224:def _calcIndependentSecondEtc(tz, x, ms):\n732:                s, d, t, microsecs = _calcIndependentSecondEtc(tz, x, ms)\n771:                s, d, t, microsecs = _calcIndependentSecondEtc(tz, x, ms)\n810:                s, d, t, microsecs = _calcIndependentSecondEtc(tz, x, ms)\n843:            s, d, t, microsecs = _calcIndependentSecondEtc(tz, x, ms)\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "filepath": "src/DateTime/DateTime.py",
  "content": "def _calcIndependentSecondEtc(tz, x, ms):\n    # Derive the timezone-independent second from the timezone\n    # dependent second.\n    fsetAtEpoch = _tzoffset(tz, 0.0)\n    nearTime = x - fsetAtEpoch - long(EPOCH) + 86400 + ms\n    # nearTime is now within an hour of being correct.\n    # Recalculate t according to DST.\n    fset = long(_tzoffset(tz, nearTime))\n    d = (x - fset) / 86400.0 + (ms / 86400.0)\n    t = x - fset - long(EPOCH) + 86400 + ms\n    micros = (x + 86400 - fset) * 1000000 + \\\n        long(round(ms * 1000000.0)) - long(EPOCH * 1000000.0)\n    s = d - math.floor(d)\n    return (s, d, t, micros)\n\n\ndef _calcHMS(x, ms):\n    # hours, minutes, seconds from integer and float.\n    hr = x // 3600\n    x = x - hr * 3600\n    mn = x // 60\n    sc = x - mn * 60 + ms\n    return (hr, mn, sc)\n\n\ndef _calcYMDHMS(x, ms):\n    # x is a timezone-dependent integer of seconds.\n    # Produces yr,mo,dy,hr,mn,sc.\n    yr, mo, dy = _calendarday(x // 86400 + jd1901)\n    x = int(x - (x // 86400) * 86400)\n    hr = x // 3600\n    x = x - hr * 3600\n    mn = x // 60\n    sc = x - mn * 60 + ms\n    return (yr, mo, dy, hr, mn, sc)\n\n",
  "start_line": 224,
  "end_line": 260,
  "total_lines": 1946,
  "is_truncated": false
}

{
  "status": "ok",
  "filepath": "src/DateTime/DateTime.py",
  "content": "                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()\n                lt = safelocaltime(t)\n                tz = self.localZone(lt)\n                yr, jul = args\n                yr = _correctYear(yr)\n                d = (_julianday(yr, 1, 0) - jd1901) + jul\n                x_float = d * 86400.0\n                x_floor = math.floor(x_float)\n                ms = x_float - x_floor\n                x = long(x_floor)\n                yr, mo, dy, hr, mn, sc = _calcYMDHMS(x, ms)\n                s, d, t, microsecs = _calcIndependentSecondEtc(tz, x, ms)\n        else:\n            # Explicit format\n            yr, mo, dy = args[:3]\n            hr, mn, sc, tz = 0, 0, 0, 0\n            yr = _correctYear(yr)\n            if not self._validDate(yr, mo, dy):\n                raise DateError('Invalid date: {}'.format(args))\n            args = args[3:]\n            if args:\n                hr, args = args[0], args[1:]\n                if args:\n                    mn, args = args[0], args[1:]\n                    if args:\n                        sc, args = args[0], args[1:]\n                        if args:\n                            tz, args = args[0], args[1:]\n                            if args:\n                                raise DateTimeError('Too many arguments')\n            if not self._validTime(hr, mn, sc):\n                raise TimeError('Invalid time: %s' % repr(args))\n\n            x = _calcDependentSecond2(yr, mo, dy, hr, mn, sc)\n            ms = sc - math.floor(sc)\n            if tz:\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            else:\n                # Get local time zone name\n                tz = self._calcTimezoneName(x, ms)\n            s, d, t, microsecs = _calcIndependentSecondEtc(tz, x, ms)\n\n        self._dayoffset = int((_julianday(yr, mo, dy) + 2) % 7)\n        # Round to nearest microsecond in platform-independent way. You\n        # cannot rely on C sprintf (Python '%') formatting to round\n        # consistently; doing it ourselves ensures that all but truly\n        # horrid C sprintf implementations will yield the same result",
  "start_line": 700,
  "end_line": 849,
  "total_lines": 1946,
  "is_truncated": true
}

{
  "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",
  "start_line": 650,
  "end_line": 680,
  "total_lines": 1946,
  "is_truncated": false
}

{
  "status": "ok",
  "stdout": "451:        return (self._micros / 1000000.0,\n1131:        return self._micros / 1000000.0\n1750:        t = tmicros / 1000000.0\n1816:        return self.micros() / 1000000.0\n1820:        return self._micros / 1000000.0\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "filepath": "src/DateTime/DateTime.py",
  "content": "        \"\"\"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:",
  "start_line": 440,
  "end_line": 460,
  "total_lines": 1946,
  "is_truncated": false
}

{
  "status": "ok",
  "filepath": "src/DateTime/DateTime.py",
  "content": "        raise AttributeError(name)\n\n    # Conversion and comparison methods\n\n    def timeTime(self):\n        \"\"\"Return the date/time as a floating-point number in UTC,\n        in the format used by the Python time module.\n\n        Note that it is possible to create date/time values with\n        DateTime that have no meaningful value to the time module.\n        \"\"\"\n        return self._micros / 1000000.0\n\n    def toZone(self, z):\n        \"\"\"Return a DateTime with the value as the current\n        object, represented in the indicated timezone.\n        \"\"\"\n        t, tz = self._t, _TZINFO._zmap[z.lower()]\n        micros = self.micros()\n        tznaive = False  # you're performing a timzone change, can't be naive\n",
  "start_line": 1120,
  "end_line": 1140,
  "total_lines": 1946,
  "is_truncated": false
}