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.assertRaises(TypeError, dt.lessThanEqualTo, \"2023\")\n        self.assertTrue(dt.notEqualTo(\"2023\"))\n        self.assertFalse(dt.equalTo(\"2023\"))\n\n    def test_compare_methods_none(self):\n        # Compare a date to None\n        for dt in (DateTime('1997/1/1'), DateTime(0)):\n            self.assertTrue(dt.greaterThan(None))\n            self.assertTrue(dt.greaterThanEqualTo(None))\n            self.assertFalse(dt.lessThan(None))\n            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": 250,
  "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",
  "stdout": "448:    def __getstate__(self):\n455:    def __setstate__(self, value):\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:\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",
  "filepath": "src/DateTime/DateTime.py",
  "content": "        \"\"\"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,\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:",
  "start_line": 471,
  "end_line": 550,
  "total_lines": 1946,
  "is_truncated": false
}

{
  "status": "ok",
  "filepath": "src/DateTime/DateTime.py",
  "content": "            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\n        If a string argument passed to the DateTime constructor cannot be",
  "start_line": 551,
  "end_line": 650,
  "total_lines": 1946,
  "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,\n             'september': 9, 'sep': 9, 'sept': 9,\n             'october': 10, 'oct': 10,\n             'november': 11, 'nov': 11,\n             'december': 12, 'dec': 12}\n_DAYS = ('Sunday', 'Monday', 'Tuesday', 'Wednesday',\n         'Thursday', 'Friday', 'Saturday')\n_DAYS_A = ('Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat')\n_DAYS_P = ('Sun.', 'Mon.', 'Tue.', 'Wed.', 'Thu.', 'Fri.', 'Sat.')\n_DAYMAP = {'sunday': 1, 'sun': 1,\n           'monday': 2, 'mon': 2,\n           'tuesday': 3, 'tues': 3, 'tue': 3,\n           'wednesday': 4, 'wed': 4,\n           'thursday': 5, 'thurs': 5, 'thur': 5, 'thu': 5,\n           'friday': 6, 'fri': 6,\n           'saturday': 7, 'sat': 7}\n\nnumericTimeZoneMatch = re.compile(r'[+-][0-9][0-9][0-9][0-9]').match\niso8601Match = re.compile(r'''\n  (?P<year>\\d\\d\\d\\d)                # four digits year\n  (?:-?                             # one optional dash\n   (?:                              # followed by:\n    (?P<year_day>\\d\\d\\d             #  three digits year day\n     (?!\\d))                        #  when there is no fourth digit\n   |                                # or:\n    W                               #  one W\n    (?P<week>\\d\\d)                  #  two digits week\n    (?:-?                           #  one optional dash\n     (?P<week_day>\\d)               #  one digit week day\n    )?                              #  week day is optional\n   |                                # or:\n    (?P<month>\\d\\d)?                #  two digits month\n    (?:-?                           #  one optional dash\n     (?P<day>\\d\\d)?                 #  two digits day\n    )?                              #  after day is optional\n   )                                #\n  )?                                # after year is optional\n  (?:[T ]                           # one T or one whitespace\n   (?P<hour>\\d\\d)                   # two digits hour\n   (?::?                            # one optional colon\n    (?P<minute>\\d\\d)?               # two digits minute\n    (?::?                           # one optional colon\n     (?P<second>\\d\\d)?              # two digits second\n     (?:[.,]                        # one dot or one comma\n      (?P<fraction>\\d+)             # n digits fraction\n     )?                             # after second is optional\n    )?                              # after minute is optional\n   )?                               # after hour is optional\n   (?:                              # timezone:\n    (?P<Z>Z)                        #  one Z\n   |                                # or:",
  "start_line": 1,
  "end_line": 150,
  "total_lines": 1946,
  "is_truncated": true
}

{
  "status": "ok",
  "filepath": "src/DateTime/DateTime.py",
  "content": "        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()\n                lt = safelocaltime(t)",
  "start_line": 651,
  "end_line": 800,
  "total_lines": 1946,
  "is_truncated": false
}

{
  "status": "ok",
  "filepath": "src/DateTime/DateTime.py",
  "content": "                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": 801,
  "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 _calcSD(t):\n    # Returns timezone-independent days since epoch and the fractional\n    # part of the days.\n    dd = t + EPOCH - 86400.0\n    d = dd / 86400.0\n    s = d - math.floor(d)\n    return s, d\n\n\ndef _calcDependentSecond(tz, t):\n    # Calculates the timezone-dependent second (integer part only)\n    # from the timezone-independent second.\n    fset = _tzoffset(tz, t)\n    return fset + long(math.floor(t)) + long(EPOCH) - 86400\n\n\ndef _calcDependentSecond2(yr, mo, dy, hr, mn, sc):\n    # Calculates the timezone-dependent second (integer part only)\n    # from the date given.\n    ss = int(hr) * 3600 + int(mn) * 60 + int(sc)\n    x = long(_julianday(yr, mo, dy) - jd1901) * 86400 + ss\n    return x\n\n\ndef _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.",
  "start_line": 200,
  "end_line": 250,
  "total_lines": 1946,
  "is_truncated": false
}

{
  "status": "error",
  "error_type": "CommandError",
  "error_message": "Traceback (most recent call last):\n  File \"<stdin>\", line 19, in <module>\nAssertionError\n",
  "details": {
    "stdout": "Original micros: 2198556426235027\nUnpickled micros: 2198556426235026\n",
    "stderr": "Traceback (most recent call last):\n  File \"<stdin>\", line 19, in <module>\nAssertionError\n",
    "exit_code": 1
  }
}