zopefoundation__DateTime-62

{
  "status": "ok",
  "stdout": "src/DateTime/tests:\n__init__.py\njulian_testdata.txt\ntest_datetime.py\n",
  "stderr": "",
  "exit_code": 0
}

{
  "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/tests/test_datetime.py",
  "content": "        self.assertTrue(dt.equalTo(1))\n        # Compare a date to string; there is no implicit type conversion\n        # but behavior if consistent as when comparing, for example, an int\n        # and a string.\n        dt = DateTime(\"2023\")\n        self.assertFalse(dt == \"2023\")  # testing __eq__\n        self.assertTrue(dt != \"2023\")  # testing __ne__\n        self.assertRaises(TypeError, dt.greaterThan, \"2023\")\n        self.assertRaises(TypeError, dt.greaterThanEqualTo, \"2023\")\n        self.assertRaises(TypeError, dt.lessThan, \"2023\")\n        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))",
  "start_line": 240,
  "end_line": 260,
  "total_lines": 746,
  "is_truncated": false
}

{
  "status": "ok",
  "stdout": "264:    def test_pickle(self):\n271:    def test_pickle_with_tz(self):\n278:    def test_pickle_asdatetime_with_tz(self):\n285:    def test_pickle_with_numerical_tz(self):\n295:    def test_pickle_with_micros(self):\n302:    def test_pickle_old(self):\n322:    def test_pickle_old_without_micros(self):\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "filepath": "src/DateTime/tests/test_datetime.py",
  "content": "    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)",
  "start_line": 264,
  "end_line": 280,
  "total_lines": 746,
  "is_truncated": false
}

{
  "status": "ok",
  "stdout": "423:    __slots__ = (\n462:                if k in self.__slots__:\n",
  "stderr": "",
  "exit_code": 0
}

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

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

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

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

{
  "status": "ok",
  "stdout": "14:import copyreg as copy_reg\n1940:orig_reconstructor = copy_reg._reconstructor\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "filepath": "src/DateTime/DateTime.py",
  "content": "            tznaive = True\n\n        # Differ from the specification here. To preserve backwards\n        # compatibility assume a default timezone == UTC.\n        tz = 'GMT%+03d%02d' % (hour_off, min_off)\n\n        return year, month, day, hour, minute, seconds, tz, tznaive\n\n    def JulianDay(self):\n        \"\"\"Return the Julian day.\n\n        See: https://www.tondering.dk/claus/cal/julperiod.php#formula\n        \"\"\"\n        a = (14 - self._month) // 12\n        y = self._year + 4800 - a\n        m = self._month + (12 * a) - 3\n        return (self._day + (153 * m + 2) // 5 + 365 * y +\n                y // 4 - y // 100 + y // 400 - 32045)\n\n    def week(self):\n        \"\"\"Return the week number according to ISO.\n\n        See: https://www.tondering.dk/claus/cal/week.php#weekno\n        \"\"\"\n        J = self.JulianDay()\n        d4 = (J + 31741 - (J % 7)) % 146097 % 36524 % 1461\n        L = d4 // 1460\n        d1 = ((d4 - L) % 365) + L\n        return d1 // 7 + 1\n\n    def encode(self, out):\n        \"\"\"Encode value for XML-RPC.\"\"\"\n        out.write('<value><dateTime.iso8601>')\n        out.write(self.ISO8601())\n        out.write('</dateTime.iso8601></value>\\n')\n\n\n# Provide the _dt_reconstructor function here, in case something\n# accidentally creates a reference to this function\n\norig_reconstructor = copy_reg._reconstructor\n\n\ndef _dt_reconstructor(cls, base, state):\n    if cls is DateTime:\n        return cls(state)\n    return orig_reconstructor(cls, base, state)",
  "start_line": 1900,
  "end_line": 1946,
  "total_lines": 1946,
  "is_truncated": false
}

{
  "status": "error",
  "error_type": "CommandError",
  "error_message": "",
  "details": {
    "stdout": "",
    "stderr": "",
    "exit_code": 1
  }
}

{
  "status": "ok",
  "stdout": "448:    def __getstate__(self):\n",
  "stderr": "",
  "exit_code": 0
}

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

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

{
  "status": "ok",
  "stdout": "v: 2198556426.235027\nres: 2198556426235026.8\nint(res): 2198556426235026\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "stdout": "res: 2198556426235026.8\nround(res): 2198556426235027\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "stdout": "234:    micros = (x + 86400 - fset) * 1000000 + \\\n235:        long(round(ms * 1000000.0)) - long(EPOCH * 1000000.0)\n451:        return (self._micros / 1000000.0,\n458:            self._micros = long(value[0] * 1000000)\n466:                self._micros = long(value['_t'] * 1000000)\n862:            microsecs = long(round(t * 1000000.0))\n1131:        return self._micros / 1000000.0\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)\n1553:        microseconds = int((zself._second - zself._nearsec) * 1000000)\n1725:        microsec = self.micros() % 1000000\n1735:        microsec = utc.micros() % 1000000\n1750:        t = tmicros / 1000000.0\n1751:        d = (tmicros + long(EPOCH * 1000000)) / 86400000000.0\n1807:        return int(self.micros() // 1000000)\n1811:        return long(self.micros() // 1000000)  # pragma: PY2\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": "        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 greater\n        than 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 True\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    __gt__ = greaterThan\n\n    def greaterThanEqualTo(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 greater\n        than or equal to the specified DateTime or time module style\n        time.\n\n        Revised to give more correct results through comparison of\n        long integer microseconds.\n        \"\"\"\n        if t is None:\n            return True\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    __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\n        Revised to give more correct results through comparison of\n        long integer microseconds.\n        \"\"\"\n        return not self.equalTo(t)\n\n    def __eq__(self, t):\n        \"\"\"Compare this DateTime object to another DateTime object.\n        Return True if their internal state is the same. Two objects\n        representing the same time in different timezones are regared as\n        unequal. Use the equalTo method if you are only interested in them\n        referring to the same moment in time.\n        \"\"\"\n        if not isinstance(t, DateTime):\n            return False\n        return (self._micros, self._tz) == (t._micros, t._tz)\n\n    def __ne__(self, t):\n        return not self.__eq__(t)\n\n    def lessThan(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 less than\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    __lt__ = lessThan\n\n    def lessThanEqualTo(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 less than\n        or equal to 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",
  "start_line": 1240,
  "end_line": 1370,
  "total_lines": 1946,
  "is_truncated": false,
  "budget_warning": "Only 10 tool call(s) remaining (20/30 used). Finalize your edits and call submit_patch soon."
}

{
  "status": "ok",
  "stdout": "Original _micros: 2198556426235027\nUnpickled _micros: 2198556426235026\nFAILURE: _micros changed after pickle/unpickle!\n",
  "stderr": "",
  "exit_code": 0,
  "budget_warning": "Only 9 tool call(s) remaining (21/30 used). Finalize your edits and call submit_patch soon."
}

{
  "status": "ok",
  "filepath": "src/DateTime/DateTime.py",
  "occurrences": 1,
  "strategy": "unescaped",
  "diff": "--- a/src/DateTime/DateTime.py\n+++ b/src/DateTime/DateTime.py\n@@ -455,7 +455,7 @@\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._micros = long(round(value[0] * 1000000))\n             self._timezone_naive = value[1]\n         else:\n             for k, v in value.items():\n",
  "is_truncated": false,
  "budget_warning": "Only 8 tool call(s) remaining (22/30 used). Finalize your edits and call submit_patch soon."
}